Add mock server

server/mock/mock.go

@@ -0,0 +1,139 @@
+package mock
+
+import (
+	"errors"
+	"sync"
+
+	"github.com/micro/go-micro/server"
+	"github.com/pborman/uuid"
+)
+
+type MockServer struct {
+	sync.Mutex
+	Running     bool
+	Opts        server.Options
+	Handlers    map[string]server.Handler
+	Subscribers map[string][]server.Subscriber
+}
+
+var (
+	_ server.Server = NewServer()
+)
+
+func newMockServer(opts ...server.Option) *MockServer {
+	var options server.Options
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	return &MockServer{
+		Opts:        options,
+		Handlers:    make(map[string]server.Handler),
+		Subscribers: make(map[string][]server.Subscriber),
+	}
+}
+
+func (m *MockServer) Options() server.Options {
+	m.Lock()
+	defer m.Unlock()
+
+	return m.Opts
+}
+
+func (m *MockServer) Init(opts ...server.Option) error {
+	m.Lock()
+	defer m.Unlock()
+
+	for _, o := range opts {
+		o(&m.Opts)
+	}
+	return nil
+}
+
+func (m *MockServer) Handle(h server.Handler) error {
+	m.Lock()
+	defer m.Unlock()
+
+	if _, ok := m.Handlers[h.Name()]; ok {
+		return errors.New("Handler " + h.Name() + " already exists")
+	}
+	m.Handlers[h.Name()] = h
+	return nil
+}
+
+func (m *MockServer) NewHandler(h interface{}, opts ...server.HandlerOption) server.Handler {
+	var options server.HandlerOptions
+	for _, o := range opts {
+		o(&options)
+	}
+
+	return &MockHandler{
+		Id:   uuid.NewUUID().String(),
+		Hdlr: h,
+		Opts: options,
+	}
+}
+
+func (m *MockServer) NewSubscriber(topic string, fn interface{}, opts ...server.SubscriberOption) server.Subscriber {
+	var options server.SubscriberOptions
+	for _, o := range opts {
+		o(&options)
+	}
+
+	return &MockSubscriber{
+		Id:   topic,
+		Sub:  fn,
+		Opts: options,
+	}
+}
+
+func (m *MockServer) Subscribe(sub server.Subscriber) error {
+	m.Lock()
+	defer m.Unlock()
+
+	subs := m.Subscribers[sub.Topic()]
+	subs = append(subs, sub)
+	m.Subscribers[sub.Topic()] = subs
+	return nil
+}
+
+func (m *MockServer) Register() error {
+	return nil
+}
+
+func (m *MockServer) Deregister() error {
+	return nil
+}
+
+func (m *MockServer) Start() error {
+	m.Lock()
+	defer m.Unlock()
+
+	if m.Running {
+		return errors.New("already running")
+	}
+
+	m.Running = true
+	return nil
+}
+
+func (m *MockServer) Stop() error {
+	m.Lock()
+	defer m.Unlock()
+
+	if !m.Running {
+		return errors.New("not running")
+	}
+
+	m.Running = false
+	return nil
+}
+
+func (m *MockServer) String() string {
+	return "mock"
+}
+
+func NewServer(opts ...server.Option) *MockServer {
+	return newMockServer(opts...)
+}

server/mock/mock_handler.go

@@ -0,0 +1,28 @@
+package mock
+
+import (
+	"github.com/micro/go-micro/registry"
+	"github.com/micro/go-micro/server"
+)
+
+type MockHandler struct {
+	Id   string
+	Opts server.HandlerOptions
+	Hdlr interface{}
+}
+
+func (m *MockHandler) Name() string {
+	return m.Id
+}
+
+func (m *MockHandler) Handler() interface{} {
+	return m.Hdlr
+}
+
+func (m *MockHandler) Endpoints() []*registry.Endpoint {
+	return []*registry.Endpoint{}
+}
+
+func (m *MockHandler) Options() server.HandlerOptions {
+	return m.Opts
+}

server/mock/mock_subscriber.go

@@ -0,0 +1,28 @@
+package mock
+
+import (
+	"github.com/micro/go-micro/registry"
+	"github.com/micro/go-micro/server"
+)
+
+type MockSubscriber struct {
+	Id   string
+	Opts server.SubscriberOptions
+	Sub  interface{}
+}
+
+func (m *MockSubscriber) Topic() string {
+	return m.Id
+}
+
+func (m *MockSubscriber) Subscriber() interface{} {
+	return m.Sub
+}
+
+func (m *MockSubscriber) Endpoints() []*registry.Endpoint {
+	return []*registry.Endpoint{}
+}
+
+func (m *MockSubscriber) Options() server.SubscriberOptions {
+	return m.Opts
+}

server/mock/mock_test.go

@@ -0,0 +1,57 @@
+package mock
+
+import (
+	"testing"
+
+	"github.com/micro/go-micro/server"
+)
+
+func TestMockServer(t *testing.T) {
+	srv := NewServer(
+		server.Name("mock"),
+		server.Version("latest"),
+	)
+
+	if srv.Options().Name != "mock" {
+		t.Fatalf("Expected name mock, got %s", srv.Options().Name)
+	}
+
+	if srv.Options().Version != "latest" {
+		t.Fatalf("Expected version latest, got %s", srv.Options().Version)
+	}
+
+	srv.Init(server.Version("test"))
+	if srv.Options().Version != "test" {
+		t.Fatalf("Expected version test, got %s", srv.Options().Version)
+	}
+
+	h := srv.NewHandler(func() string { return "foo" })
+	if err := srv.Handle(h); err != nil {
+		t.Fatal(err)
+	}
+
+	sub := srv.NewSubscriber("test", func() string { return "foo" })
+	if err := srv.Subscribe(sub); err != nil {
+		t.Fatal(err)
+	}
+
+	if sub.Topic() != "test" {
+		t.Fatalf("Expected topic test got %s", sub.Topic())
+	}
+
+	if err := srv.Start(); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := srv.Register(); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := srv.Deregister(); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := srv.Stop(); err != nil {
+		t.Fatal(err)
+	}
+}