Merge branch 'redis-fixes' into 'master'

Redis fixes

Closes #117 and #114

See merge request !140

.gitignore

@@ -5,3 +5,5 @@ testdata/public
 /gitlab-zip-cat
 /gitlab-zip-metadata
 /_build
+# Avoid distributing redigomock because it is GPLv2
+/vendor/github.com/rafaeljusto/redigomock

Makefile

@@ -2,6 +2,7 @@ PREFIX=/usr/local
 VERSION=$(shell git describe)-$(shell date -u +%Y%m%d.%H%M%S)
 BUILD_DIR = $(shell pwd)
 export GOPATH=${BUILD_DIR}/_build
+export PATH:=${GOPATH}/bin:${PATH}
 export GO15VENDOREXPERIMENT=1
 GOBUILD=go build -ldflags "-X main.Version=${VERSION}"
 PKG=gitlab.com/gitlab-org/gitlab-workhorse
@@ -28,11 +29,16 @@ ${BUILD_DIR}/_build:
 	touch $@
 
 .PHONY: test
-test:	clean-build clean-workhorse all
+test:	clean-build clean-workhorse all govendor
 	go fmt ${PKG_ALL} | awk '{ print } END { if (NR > 0) { print "Please run go fmt"; exit 1 } }'
+	cd ${GOPATH}/src/${PKG} && govendor sync
 	go test ${PKG_ALL}
 	@echo SUCCESS
 
+.PHONY:	govendor
+govendor:
+	command -v govendor || go get github.com/kardianos/govendor
+
 coverage:
 	go test -cover -coverprofile=test.coverage
 	go tool cover -html=test.coverage -o coverage.html

internal/redis/keywatcher.go

@@ -72,13 +72,13 @@ func processInner(conn redis.Conn) error {
 			dataStr := string(v.Data)
 			msg := strings.SplitN(dataStr, "=", 2)
 			if len(msg) != 2 {
-				helper.LogError(nil, fmt.Errorf("Redis receive error: got an invalid notification: %q", dataStr))
+				helper.LogError(nil, fmt.Errorf("keywatcher: invalid notification: %q", dataStr))
 				continue
 			}
 			key, value := msg[0], msg[1]
 			notifyChanWatchers(key, value)
 		case error:
-			helper.LogError(nil, fmt.Errorf("Redis receive error: %s", v))
+			helper.LogError(nil, fmt.Errorf("keywatcher: pubsub receive: %v", v))
 			// Intermittent error, return nil so that it doesn't wait before reconnect
 			return nil
 		}
@@ -105,21 +105,18 @@ func dialPubSub(dialer redisDialerFunc) (redis.Conn, error) {
 //
 // NOTE: There Can Only Be One!
 func Process() {
-	log.Print("Processing redis queue")
-
+	log.Print("keywatcher: starting process loop")
 	for {
-		log.Println("Connecting to redis")
-
 		conn, err := dialPubSub(workerDialFunc)
 		if err != nil {
-			helper.LogError(nil, fmt.Errorf("Failed to connect to redis: %s", err))
+			helper.LogError(nil, fmt.Errorf("keywatcher: %v", err))
 			time.Sleep(redisReconnectTimeout.Duration())
 			continue
 		}
 		redisReconnectTimeout.Reset()
 
 		if err = processInner(conn); err != nil {
-			helper.LogError(nil, fmt.Errorf("Failed to process redis-queue: %s", err))
+			helper.LogError(nil, fmt.Errorf("keywatcher: process loop: %v", err))
 		}
 	}
 }
@@ -187,7 +184,7 @@ func WatchKey(key, value string, timeout time.Duration) (WatchKeyStatus, error)
 
 	currentValue, err := GetString(key)
 	if err != nil {
-		return WatchKeyStatusNoChange, fmt.Errorf("Failed to get value from Redis: %#v", err)
+		return WatchKeyStatusNoChange, fmt.Errorf("keywatcher: redis GET: %v", err)
 	}
 	if currentValue != value {
 		return WatchKeyStatusAlreadyChanged, nil
@@ -196,7 +193,7 @@ func WatchKey(key, value string, timeout time.Duration) (WatchKeyStatus, error)
 	select {
 	case currentValue := <-kw.Chan:
 		if currentValue == "" {
-			return WatchKeyStatusNoChange, fmt.Errorf("Failed to get value from Redis")
+			return WatchKeyStatusNoChange, fmt.Errorf("keywatcher: redis GET failed")
 		}
 		if currentValue == value {
 			return WatchKeyStatusNoChange, nil

internal/redis/redis.go

@@ -3,6 +3,7 @@ package redis
 import (
 	"errors"
 	"fmt"
+	"log"
 	"net"
 	"net/url"
 	"time"
@@ -63,7 +64,9 @@ func sentinelConn(master string, urls []config.TomlURL) *sentinel.Sentinel {
 	}
 	var addrs []string
 	for _, url := range urls {
-		addrs = append(addrs, url.URL.String())
+		h := url.URL.Host
+		log.Printf("redis: using sentinel %q", h)
+		addrs = append(addrs, h)
 	}
 	return &sentinel.Sentinel{
 		Addrs:      addrs,
@@ -151,20 +154,25 @@ func sentinelDialer(dopts []redis.DialOption, keepAlivePeriod time.Duration) red
 			return nil, err
 		}
 		dopts = append(dopts, redis.DialNetDial(keepAliveDialer(keepAlivePeriod)))
-		return redis.Dial("tcp", address, dopts...)
+		return redisDial("tcp", address, dopts...)
 	}
 }
 
 func defaultDialer(dopts []redis.DialOption, keepAlivePeriod time.Duration, url url.URL) redisDialerFunc {
 	return func() (redis.Conn, error) {
 		if url.Scheme == "unix" {
-			return redis.Dial(url.Scheme, url.Path, dopts...)
+			return redisDial(url.Scheme, url.Path, dopts...)
 		}
 		dopts = append(dopts, redis.DialNetDial(keepAliveDialer(keepAlivePeriod)))
-		return redis.Dial(url.Scheme, url.Host, dopts...)
+		return redisDial(url.Scheme, url.Host, dopts...)
 	}
 }
 
+func redisDial(network, address string, options ...redis.DialOption) (redis.Conn, error) {
+	log.Printf("redis: dialing %q, %q", network, address)
+	return redis.Dial(network, address, options...)
+}
+
 func countDialer(dialer redisDialerFunc) redisDialerFunc {
 	return func() (redis.Conn, error) {
 		c, err := dialer()
@@ -233,7 +241,7 @@ func Get() redis.Conn {
 func GetString(key string) (string, error) {
 	conn := Get()
 	if conn == nil {
-		return "", fmt.Errorf("Not connected to redis")
+		return "", fmt.Errorf("redis: could not get connection from pool")
 	}
 	defer conn.Close()
 

internal/redis/redis_test.go

@@ -100,19 +100,19 @@ func TestSentinelConnNoSentinel(t *testing.T) {
 }
 
 func TestSentinelConnTwoURLs(t *testing.T) {
-	urls := []string{"tcp://10.0.0.1:12345", "tcp://10.0.0.2:12345"}
+	addrs := []string{"10.0.0.1:12345", "10.0.0.2:12345"}
 	var sentinelUrls []config.TomlURL
 
-	for _, url := range urls {
-		parsedURL := helper.URLMustParse(url)
+	for _, a := range addrs {
+		parsedURL := helper.URLMustParse(`tcp://` + a)
 		sentinelUrls = append(sentinelUrls, config.TomlURL{URL: *parsedURL})
 	}
 
 	s := sentinelConn("foobar", sentinelUrls)
-	assert.Equal(t, len(urls), len(s.Addrs))
+	assert.Equal(t, len(addrs), len(s.Addrs))
 
-	for i := range urls {
-		assert.Equal(t, urls[i], s.Addrs[i])
+	for i := range addrs {
+		assert.Equal(t, addrs[i], s.Addrs[i])
 	}
 }
 

main.go

@@ -133,8 +133,10 @@ func main() {
 
 		cfg.Redis = cfgFromFile.Redis
 
-		redis.Configure(cfg.Redis, redis.DefaultDialFunc)
-		go redis.Process()
+		if cfg.Redis != nil {
+			redis.Configure(cfg.Redis, redis.DefaultDialFunc)
+			go redis.Process()
+		}
 	}
 
 	up := wrapRaven(upstream.NewUpstream(cfg))

vendor/github.com/rafaeljusto/redigomock/AUTHORS

-Rafael Dantas Justo - @rafaeljusto 

vendor/github.com/rafaeljusto/redigomock/CONTRIBUTORS

-Charles Law        - @clawconduce
-Maciej Galkowski   - @szank
-Zachery Moneypenny - @whazzmaster

vendor/github.com/rafaeljusto/redigomock/Changelog

-# Change Log
-All notable changes to this project will be documented in this file.
-This project adheres to [Semantic Versioning](http://semver.org/).
-
-## [2.0.0] - 2016-05-24
-### Added
-- Fuzzy matching for redigomock command arguments
-- Make commands a property of a connection object, which allows to run tests in parallel
-- Commands calls counters, which allows to identify unused mocked commands (thanks to @rylnd)
-
-### Changed
-- Improve error message adding argument suggestions
-
-## [1.0.0] - 2015-04-23
-### Added
-- Support to mock commands taking into account the arguments or not
-- Support to mock PubSub using a wait Go channel
-- Support to multiple (sequentially returned) responses for single command
-- Support to mock scripts

vendor/github.com/rafaeljusto/redigomock/LICENSE

-GNU GENERAL PUBLIC LICENSE
-                       Version 2, June 1991
-
- Copyright (C) 1989, 1991 Free Software Foundation, Inc., <http://fsf.org/>
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Lesser General Public License instead.)  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must show them these terms so they know their
-rights.
-
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                    GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-  1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
-  2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
-
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-    a) Accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of Sections
-    1 and 2 above on a medium customarily used for software interchange; or,
-
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
-
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable.  However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-  5. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-  9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Program
-specifies a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-                            NO WARRANTY
-
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    {description}
-    Copyright (C) {year}  {fullname}
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-    Gnomovision version 69, Copyright (C) year name of author
-    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-  `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-  {signature of Ty Coon}, 1 April 1989
-  Ty Coon, President of Vice
-
-This General Public License does not permit incorporating your program into
-proprietary programs.  If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.
\ No newline at end of file

vendor/github.com/rafaeljusto/redigomock/README.md

-redigomock
-==========
-
-[![Build Status](https://travis-ci.org/rafaeljusto/redigomock.png?branch=master)](https://travis-ci.org/rafaeljusto/redigomock)
-[![GoDoc](https://godoc.org/github.com/rafaeljusto/redigomock?status.png)](https://godoc.org/github.com/rafaeljusto/redigomock)
-
-Easy way to unit test projects using [redigo library](https://github.com/garyburd/redigo) (Redis client in go). You can find the latest release [here](https://github.com/rafaeljusto/redigomock/releases).
-
-install
--------
-
-```
-go get -u github.com/rafaeljusto/redigomock
-```
-
-usage
------
-
-Here is an example of using redigomock, for more information please check the [API documentation](https://godoc.org/github.com/rafaeljusto/redigomock).
-
-```go
-package main
-
-import (
-	"fmt"
-	"github.com/garyburd/redigo/redis"
-	"github.com/rafaeljusto/redigomock"
-)
-
-type Person struct {
-	Name string `redis:"name"`
-	Age  int    `redis:"age"`
-}
-
-func RetrievePerson(conn redis.Conn, id string) (Person, error) {
-	var person Person
-
-	values, err := redis.Values(conn.Do("HGETALL", fmt.Sprintf("person:%s", id)))
-	if err != nil {
-		return person, err
-	}
-
-	err = redis.ScanStruct(values, &person)
-	return person, err
-}
-
-func main() {
-	// Simulate command result
-
-	conn := redigomock.NewConn()
-	cmd := conn.Command("HGETALL", "person:1").ExpectMap(map[string]string{
-		"name": "Mr. Johson",
-		"age":  "42",
-	})
-
-	person, err := RetrievePerson(conn, "1")
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
-
-	if conn.Stats(cmd) != 1 {
-		fmt.Println("Command was not used")
-		return
-	}
-
-	if person.Name != "Mr. Johson" {
-		fmt.Printf("Invalid name. Expected 'Mr. Johson' and got '%s'\n", person.Name)
-		return
-	}
-
-	if person.Age != 42 {
-		fmt.Printf("Invalid age. Expected '42' and got '%d'\n", person.Age)
-		return
-	}
-
-	// Simulate command error
-
-	conn.Clear()
-	cmd = conn.Command("HGETALL", "person:1").ExpectError(fmt.Errorf("Simulate error!"))
-
-	person, err = RetrievePerson(conn, "1")
-	if err == nil {
-		fmt.Println("Should return an error!")
-		return
-	}
-
-	if conn.Stats(cmd) != 1 {
-		fmt.Println("Command was not used")
-		return
-	}
-
-	fmt.Println("Success!")
-}
-```
-
-mocking a subscription
-----------------------
-
-```go
-func CreateSubscriptionMessage(data []byte) []interface{} {
-    values := []interface{}{}
-    values = append(values, interface{}([]byte("message")))
-    values = append(values, interface{}([]byte("chanName")))
-    values = append(values, interface{}(data))
-    return values
-}
-
-rconnSub := redigomock.NewConn()
-
-// Setup the initial subscription message
-values := []interface{}{}
-values = append(values, interface{}([]byte("subscribe")))
-values = append(values, interface{}([]byte("chanName")))
-values = append(values, interface{}([]byte("1")))
-cmd := rconnSub.Command("SUBSCRIBE", subKey).Expect(values)
-rconnSub.ReceiveWait = true
-
-// Add a response that will come back as a subscription message
-rconnSub.AddSubscriptionMessage(CreateSubscriptionMessage([]byte("hello")))
-
-//You need to send messages to rconnSub.ReceiveNow in order to get a response.
-//Sending to this channel will block until receive, so do it in a goroutine
-go func() {
-    rconnSub.ReceiveNow <- true //This unlocks the subscribe message
-    rconnSub.ReceiveNow <- true //This sends the "hello" message
-}()
-```

vendor/github.com/rafaeljusto/redigomock/command.go

-// Copyright 2014 Rafael Dantas Justo. All rights reserved.
-// Use of this source code is governed by a GPL
-// license that can be found in the LICENSE file.
-
-package redigomock
-
-import (
-	"fmt"
-	"reflect"
-)
-
-// Response struct that represents single response from `Do` call
-type Response struct {
-	Response interface{} // Response to send back when this command/arguments are called
-	Error    error       // Error to send back when this command/arguments are called
-}
-
-// Cmd stores the registered information about a command to return it later
-// when request by a command execution
-type Cmd struct {
-	Name      string        // Name of the command
-	Args      []interface{} // Arguments of the command
-	Responses []Response    // Slice of returned responses
-}
-
-// cmdHash stores a unique identifier of the command
-type cmdHash string
-
-// equal verify if a command/argumets is related to a registered command
-func equal(commandName string, args []interface{}, cmd *Cmd) bool {
-	if commandName != cmd.Name || len(args) != len(cmd.Args) {
-		return false
-	}
-
-	for pos := range cmd.Args {
-		if implementsFuzzy(cmd.Args[pos]) && implementsFuzzy(args[pos]) {
-			if reflect.TypeOf(cmd.Args[pos]) != reflect.TypeOf(args[pos]) {
-				return false
-			}
-		} else if implementsFuzzy(cmd.Args[pos]) || implementsFuzzy(args[pos]) {
-			return false
-		} else {
-			if reflect.DeepEqual(cmd.Args[pos], args[pos]) == false {
-				return false
-			}
-		}
-	}
-	return true
-}
-
-// match check if provided arguments can be matched with any registered
-// commands
-func match(commandName string, args []interface{}, cmd *Cmd) bool {
-	if commandName != cmd.Name || len(args) != len(cmd.Args) {
-		return false
-	}
-
-	for pos := range cmd.Args {
-		if implementsFuzzy(cmd.Args[pos]) {
-			if cmd.Args[pos].(FuzzyMatcher).Match(args[pos]) == false {
-				return false
-			}
-		} else if reflect.DeepEqual(cmd.Args[pos], args[pos]) == false {
-			return false
-		}
-
-	}
-	return true
-}
-
-// Expect sets a response for this command. Everytime a Do or Receive methods
-// are executed for a registered command this response or error will be
-// returned. Expect call returns a pointer to Cmd struct, so you can chain
-// Expect calls. Chained responses will be returned on subsequent calls
-// matching this commands arguments in FIFO order
-func (c *Cmd) Expect(response interface{}) *Cmd {
-	c.Responses = append(c.Responses, Response{response, nil})
-	return c
-}
-
-// ExpectMap works in the same way of the Expect command, but has a key/value
-// input to make it easier to build test environments
-func (c *Cmd) ExpectMap(response map[string]string) *Cmd {
-	var values []interface{}
-	for key, value := range response {
-		values = append(values, []byte(key))
-		values = append(values, []byte(value))
-	}
-	c.Responses = append(c.Responses, Response{values, nil})
-	return c
-}
-
-// ExpectError allows you to force an error when executing a
-// command/arguments
-func (c *Cmd) ExpectError(err error) *Cmd {
-	c.Responses = append(c.Responses, Response{nil, err})
-	return c
-}
-
-// ExpectSlice make it easier to expect slice value
-// e.g - HMGET command
-func (c *Cmd) ExpectSlice(resp ...interface{}) *Cmd {
-	response := []interface{}{}
-	for _, r := range resp {
-		response = append(response, r)
-	}
-	c.Responses = append(c.Responses, Response{response, nil})
-	return c
-}
-
-// hash generates a unique identifier for the command
-func (c Cmd) hash() cmdHash {
-	output := c.Name
-	for _, arg := range c.Args {
-		output += fmt.Sprintf("%v", arg)
-	}
-	return cmdHash(output)
-}

vendor/github.com/rafaeljusto/redigomock/doc.go

-// Copyright 2014 Rafael Dantas Justo. All rights reserved.
-
-// Use of this source code is governed by a GPL
-// license that can be found in the LICENSE file.
-
-// Package redigomock is a mock for redigo library (redis client)
-//
-// Redigomock basically register the commands with the expected results in a internal global
-// variable. When the command is executed via Conn interface, the mock will look to this global
-// variable to retrieve the corresponding result.
-//
-// To start a mocked connection just do the following:
-//
-//  c := redigomock.NewConn()
-//
-// Now you can inject it whenever your system needs a redigo.Conn because it satisfies all interface
-// requirements. Before running your tests you need beyond of mocking the connection, registering
-// the expected results. For that you can generate commands with the expected results.
-//
-//  c.Command("HGETALL", "person:1").Expect("Person!")
-//  c.Command(
-//    "HMSET", []string{"person:1", "name", "John"},
-//  ).Expect("ok")
-//
-// As the Expect method from Command receives anything (interface{}), another method was created to
-// easy map the result to your structure. For that use ExpectMap:
-//
-//  c.Command("HGETALL", "person:1").ExpectMap(map[string]string{
-//    "name": "John",
-//    "age": 42,
-//  })
-//
-// You should also test the error cases, and you can do it in the same way of a normal result.
-//
-//  c.Command("HGETALL", "person:1").ExpectError(fmt.Errorf("Low level error!"))
-//
-// Sometimes you will want to register a command regardless the arguments, and you can do it with
-// the method GenericCommand (mainly with the HMSET).
-//
-//  c.GenericCommand("HMSET").Expect("ok")
-//
-// All commands are registered in a global variable, so they will be there until all your test cases
-// ends. So for good practice in test writing you should in the beginning of each test case clear
-// the mock states.
-//
-//  c.Clear()
-//
-// Let's see a full test example. Imagine a Person structure and a function that pick up this
-// person in Redis using redigo library (file person.go):
-//
-//  package person
-//
-//  import (
-//    "fmt"
-//    "github.com/garyburd/redigo/redis"
-//  )
-//
-//  type Person struct {
-//    Name string `redis:"name"`
-//    Age  int    `redis:"age"`
-//  }
-//
-//  func RetrievePerson(conn redis.Conn, id string) (Person, error) {
-//    var person Person
-//
-//    values, err := redis.Values(conn.Do("HGETALL", fmt.Sprintf("person:%s", id)))
-//    if err != nil {
-//      return person, err
-//    }
-//
-//    err = redis.ScanStruct(values, &person)
-//    return person, err
-//  }
-//
-// Now we need to test it, so let's create the corresponding test with redigomock
-// (fileperson_test.go):
-//
-//  package person
-//
-//  import (
-//    "github.com/rafaeljusto/redigomock"
-//    "testing"
-//  )
-//
-//  func TestRetrievePerson(t *testing.T) {
-//    conn := redigomock.NewConn()
-//    cmd := conn.Command("HGETALL", "person:1").ExpectMap(map[string]string{
-//      "name": "Mr. Johson",
-//      "age":  "42",
-//    })
-//
-//    person, err := RetrievePerson(conn, "1")
-//    if err != nil {
-//      t.Fatal(err)
-//    }
-//
-//    if conn.Stats(cmd) != 1 {
-//      t.Fatal("Command was not called!")
-//    }
-//
-//    if person.Name != "Mr. Johson" {
-//      t.Errorf("Invalid name. Expected 'Mr. Johson' and got '%s'", person.Name)
-//    }
-//
-//    if person.Age != 42 {
-//      t.Errorf("Invalid age. Expected '42' and got '%d'", person.Age)
-//    }
-//  }
-//
-//  func TestRetrievePersonError(t *testing.T) {
-//    conn := redigomock.NewConn()
-//    conn.Command("HGETALL", "person:1").ExpectError(fmt.Errorf("Simulate error!"))
-//
-//    person, err = RetrievePerson(conn, "1")
-//    if err == nil {
-//      t.Error("Should return an error!")
-//    }
-//  }
-//
-// When you use redis as a persistent list, then you might want to call the
-// same redis command multiple times. For example:
-//
-//  func PollForData(conn redis.Conn) error {
-//    var url string
-//    var err error
-//
-//    for {
-//      if url, err = conn.Do("LPOP", "URLS"); err != nil {
-//        return err
-//      }
-//
-//      go func(input string) {
-//        // do something with the input
-//      }(url)
-//    }
-//
-//    panic("Shouldn't be here")
-//  }
-//
-// To test it, you can chain redis responses. Let's write a test case:
-//
-//  func TestPollForData(t *testing.T) {
-//    conn := redigomock.NewConn()
-//    conn.Command("LPOP", "URLS").
-//      Expect("www.some.url.com").
-//      Expect("www.another.url.com").
-//      ExpectError(redis.ErrNil)
-//
-//    if err := PollForData(conn); err != redis.ErrNil {
-//      t.Error("This should return redis nil Error")
-//    }
-//  }
-//
-// In the first iteration of the loop redigomock would return
-// "www.some.url.com", then "www.another.url.com" and finally redis.ErrNil.
-//
-// Sometimes providing expected arguments to redigomock at compile time could
-// be too constraining. Let's imagine you use redis hash sets to store some
-// data, along with the timestamp of the last data update. Let's expand our
-// Person struct:
-//
-//  type Person struct {
-//    Name      string `redis:"name"`
-//    Age       int    `redis:"age"`
-//    UpdatedAt uint64 `redis:updatedat`
-//    Phone     string `redis:phone`
-//  }
-//
-// And add a function updating personal data (phone number for example).
-// Please notice that the update timestamp can't be determined at compile time:
-//
-//  func UpdatePersonalData(conn redis.Conn, id string, person Person) error {
-//    _, err := conn.Do("HMSET", fmt.Sprint("person:", id), "name", person.Name, "age", person.Age, "updatedat" , time.Now.Unix(), "phone" , person.Phone)
-//    return err
-//  }
-//
-// Unit test:
-//
-//  func TestUpdatePersonalData(t *testing.T){
-//    redigomock.Clear()
-//
-//    person := Person{
-//      Name  : "A name",
-//      Age   : 18
-//      Phone : "123456"
-//    }
-//
-//    conn := redigomock.NewConn()
-//    conn.Commmand("HMSET", "person:1", "name", person.Name, "age", person.Age, "updatedat", redigomock.NewAnyInt(), "phone", person.Phone).Expect("OK!")
-//
-//    err := UpdatePersonalData(conn, "1", person)
-//    if err != nil {
-//      t.Error("This shouldn't return any errors")
-//    }
-//  }
-//
-// As you can see at the position of current timestamp redigomock is told to
-// match AnyInt struct created by NewAnyInt() method. AnyInt struct will match
-// any integer passed to redigomock from the tested method. Please see
-// fuzzyMatch.go file for more details.
-package redigomock

vendor/github.com/rafaeljusto/redigomock/fuzzy_match.go

-package redigomock
-
-import "reflect"
-
-// FuzzyMatcher is an interface that exports exports one function. It can be
-// passed to the Command as a argument. When the command is evaluated agains
-// data provided in mock connection Do call, FuzzyMatcher will call Match on the
-// argument and returns true if argument fulfils constraints set in concrete
-// implementation
-type FuzzyMatcher interface {
-
-	// Match takes an argument passed to mock connection Do call and check if
-	// it fulfills constraints set in concrete implementation of this interface
-	Match(interface{}) bool
-}
-
-// NewAnyInt returns a FuzzyMatcher instance matching any integer passed as an
-// argument
-func NewAnyInt() FuzzyMatcher {
-	return anyInt{}
-}
-
-// NewAnyDouble returns a FuzzyMatcher instance mathing any double passed as
-// an argument
-func NewAnyDouble() FuzzyMatcher {
-	return anyDouble{}
-}
-
-// NewAnyData returns a FuzzyMatcher instance matching every data passed as
-// an arguments (returns true by default)
-func NewAnyData() FuzzyMatcher {
-	return anyData{}
-}
-
-type anyInt struct{}
-
-func (matcher anyInt) Match(input interface{}) bool {
-	switch input.(type) {
-	case int, int8, int16, int32, int64, uint8, uint16, uint32, uint64:
-		return true
-	default:
-		return false
-	}
-}
-
-type anyDouble struct{}
-
-func (matcher anyDouble) Match(input interface{}) bool {
-	switch input.(type) {
-	case float32, float64:
-		return true
-	default:
-		return false
-	}
-}
-
-type anyData struct{}
-
-func (matcher anyData) Match(input interface{}) bool {
-	return true
-}
-
-func implementsFuzzy(input interface{}) bool {
-	return reflect.TypeOf(input).Implements(reflect.TypeOf((*FuzzyMatcher)(nil)).Elem())
-}

vendor/github.com/rafaeljusto/redigomock/redigomock.go

-// Copyright 2014 Rafael Dantas Justo. All rights reserved.
-// Use of this source code is governed by a GPL
-// license that can be found in the LICENSE file.
-
-package redigomock
-
-import (
-	"crypto/sha1"
-	"encoding/hex"
-	"fmt"
-	"sync"
-)
-
-type queueElement struct {
-	commandName string
-	args        []interface{}
-}
-
-// Conn is the struct that can be used where you inject the redigo.Conn on
-// your project
-type Conn struct {
-	SubResponses []Response      // Queue responses for PubSub
-	ReceiveWait  bool            // When set to true, Receive method will wait for a value in ReceiveNow channel to proceed, this is useful in a PubSub scenario
-	ReceiveNow   chan bool       // Used to lock Receive method to simulate a PubSub scenario
-	CloseMock    func() error    // Mock the redigo Close method
-	ErrMock      func() error    // Mock the redigo Err method
-	FlushMock    func() error    // Mock the redigo Flush method
-	commands     []*Cmd          // Slice that stores all registered commands for each connection
-	queue        []queueElement  // Slice that stores all queued commands for each connection
-	stats        map[cmdHash]int // Command calls counter
-	statsMut     sync.RWMutex    // Locks the stats so we don't get concurrent map writes
-}
-
-// NewConn returns a new mocked connection. Obviously as we are mocking we
-// don't need any Redis connection parameter
-func NewConn() *Conn {
-	return &Conn{
-		ReceiveNow: make(chan bool),
-		stats:      make(map[cmdHash]int),
-	}
-}
-
-// Close can be mocked using the Conn struct attributes
-func (c *Conn) Close() error {
-	if c.CloseMock == nil {
-		return nil
-	}
-
-	return c.CloseMock()
-}
-
-// Err can be mocked using the Conn struct attributes
-func (c *Conn) Err() error {
-	if c.ErrMock == nil {
-		return nil
-	}
-
-	return c.ErrMock()
-}
-
-// Command register a command in the mock system using the same arguments of
-// a Do or Send commands. It will return a registered command object where
-// you can set the response or error
-func (c *Conn) Command(commandName string, args ...interface{}) *Cmd {
-	cmd := &Cmd{
-		Name: commandName,
-		Args: args,
-	}
-	c.removeRelatedCommands(commandName, args)
-	c.commands = append(c.commands, cmd)
-	return cmd
-}
-
-// Script registers a command in the mock system just like Command method
-// would do. The first argument is a byte array with the script text, next
-// ones are the ones you would pass to redis Script.Do() method
-func (c *Conn) Script(scriptData []byte, keyCount int, args ...interface{}) *Cmd {
-	h := sha1.New()
-	h.Write(scriptData)
-	sha1sum := hex.EncodeToString(h.Sum(nil))
-
-	newArgs := make([]interface{}, 2+len(args))
-	newArgs[0] = sha1sum
-	newArgs[1] = keyCount
-	copy(newArgs[2:], args)
-
-	return c.Command("EVALSHA", newArgs...)
-}
-
-// GenericCommand register a command without arguments. If a command with
-// arguments doesn't match with any registered command, it will look for
-// generic commands before throwing an error
-func (c *Conn) GenericCommand(commandName string) *Cmd {
-	cmd := &Cmd{
-		Name: commandName,
-	}
-
-	c.removeRelatedCommands(commandName, nil)
-	c.commands = append(c.commands, cmd)
-	return cmd
-}
-
-// find will scan the registered commands, looking for the first command with
-// the same name and arguments. If the command is not found nil is returned
-func (c *Conn) find(commandName string, args []interface{}) *Cmd {
-	for _, cmd := range c.commands {
-		if match(commandName, args, cmd) {
-			return cmd
-		}
-	}
-	return nil
-}
-
-// removeRelatedCommands verify if a command is already registered, removing
-// any command already registered with the same name and arguments. This
-// should avoid duplicated mocked commands
-func (c *Conn) removeRelatedCommands(commandName string, args []interface{}) {
-	var unique []*Cmd
-
-	for _, cmd := range c.commands {
-		// new array will contain only commands that are not related to the given
-		// one
-		if !equal(commandName, args, cmd) {
-			unique = append(unique, cmd)
-		}
-	}
-	c.commands = unique
-}
-
-// Clear removes all registered commands. Useful for connection reuse in test
-// scenarios
-func (c *Conn) Clear() {
-	c.statsMut.Lock()
-	defer c.statsMut.Unlock()
-
-	c.commands = []*Cmd{}
-	c.queue = []queueElement{}
-	c.stats = make(map[cmdHash]int)
-}
-
-// Do looks in the registered commands (via Command function) if someone
-// matches with the given command name and arguments, if so the corresponding
-// response or error is returned. If no registered command is found an error
-// is returned
-func (c *Conn) Do(commandName string, args ...interface{}) (reply interface{}, err error) {
-	// @whazzmaster: Ensures that a call to Do() flushes the command queue
-	//
-	// The redigo package ensures that a call to Do() will flush any commands
-	// that were queued via the Send() method, however a call to Do() on the
-	// mock does not empty the queued commands
-	for _, cmd := range c.queue {
-		if _, err = c.do(cmd.commandName, cmd.args...); err != nil {
-			return
-		}
-	}
-	c.queue = []queueElement{}
-
-	return c.do(commandName, args...)
-}
-
-func (c *Conn) do(commandName string, args ...interface{}) (reply interface{}, err error) {
-	cmd := c.find(commandName, args)
-	if cmd == nil {
-		// Didn't find a specific command, try to get a generic one
-		if cmd = c.find(commandName, nil); cmd == nil {
-			var msg string
-			for _, regCmd := range c.commands {
-				if commandName == regCmd.Name {
-					if len(msg) == 0 {
-						msg = ". Possible matches are with the arguments:"
-					}
-					msg += fmt.Sprintf("\n* %#v", regCmd.Args)
-				}
-			}
-
-			return nil, fmt.Errorf("command %s with arguments %#v not registered in redigomock library%s",
-				commandName, args, msg)
-		}
-	}
-
-	c.statsMut.Lock()
-	c.stats[cmd.hash()]++
-	c.statsMut.Unlock()
-
-	if len(cmd.Responses) == 0 {
-		return nil, nil
-	}
-
-	response := cmd.Responses[0]
-	cmd.Responses = cmd.Responses[1:]
-	return response.Response, response.Error
-}
-
-// Send stores the command and arguments to be executed later (by the Receive
-// function) in a first-come first-served order
-func (c *Conn) Send(commandName string, args ...interface{}) error {
-	c.queue = append(c.queue, queueElement{
-		commandName: commandName,
-		args:        args,
-	})
-	return nil
-}
-
-// Flush can be mocked using the Conn struct attributes
-func (c *Conn) Flush() error {
-	if c.FlushMock == nil {
-		return nil
-	}
-
-	return c.FlushMock()
-}
-
-func (c *Conn) AddSubscriptionMessage(msg interface{}) {
-	resp := Response{}
-	resp.Response = msg
-	c.SubResponses = append(c.SubResponses, resp)
-}
-
-// Receive will process the queue created by the Send method, only one item
-// of the queue is processed by Receive call. It will work as the Do method
-func (c *Conn) Receive() (reply interface{}, err error) {
-	if c.ReceiveWait {
-		<-c.ReceiveNow
-	}
-
-	if len(c.queue) == 0 {
-		if len(c.SubResponses) > 0 {
-			reply, err = c.SubResponses[0].Response, c.SubResponses[0].Error
-			c.SubResponses = c.SubResponses[1:]
-			return
-		}
-		return nil, fmt.Errorf("no more items")
-	}
-	commandName, args := c.queue[0].commandName, c.queue[0].args
-	cmd := c.find(commandName, args)
-	if cmd == nil {
-		// Didn't find a specific command, try to get a generic one
-		if cmd = c.find(commandName, nil); cmd == nil {
-			return nil, fmt.Errorf("command %s with arguments %#v not registered in redigomock library",
-				commandName, args)
-		}
-	}
-
-	c.statsMut.Lock()
-	c.stats[cmd.hash()]++
-	c.statsMut.Unlock()
-
-	if len(cmd.Responses) == 0 {
-		reply, err = nil, nil
-	} else {
-		response := cmd.Responses[0]
-		cmd.Responses = cmd.Responses[1:]
-
-		reply, err = response.Response, response.Error
-	}
-
-	c.queue = c.queue[1:]
-	return
-}
-
-// Stats returns the number of times that a command was called in the current
-// connection
-func (c Conn) Stats(cmd *Cmd) int {
-	c.statsMut.RLock()
-	defer c.statsMut.RUnlock()
-	
-	return c.stats[cmd.hash()]
-}