From ca91a8383e26ab4a95892d3d2314a13d87948e25 Mon Sep 17 00:00:00 2001 From: Asim Date: Sat, 16 Apr 2016 00:02:55 +0100 Subject: [PATCH] Add mock server --- server/mock/mock.go | 139 +++++++++++++++++++++++++++++++++ server/mock/mock_handler.go | 28 +++++++ server/mock/mock_subscriber.go | 28 +++++++ server/mock/mock_test.go | 57 ++++++++++++++ 4 files changed, 252 insertions(+) create mode 100644 server/mock/mock.go create mode 100644 server/mock/mock_handler.go create mode 100644 server/mock/mock_subscriber.go create mode 100644 server/mock/mock_test.go diff --git a/server/mock/mock.go b/server/mock/mock.go new file mode 100644 index 00000000..f853b905 --- /dev/null +++ b/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...) +} diff --git a/server/mock/mock_handler.go b/server/mock/mock_handler.go new file mode 100644 index 00000000..e08efc06 --- /dev/null +++ b/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 +} diff --git a/server/mock/mock_subscriber.go b/server/mock/mock_subscriber.go new file mode 100644 index 00000000..e5de5396 --- /dev/null +++ b/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 +} diff --git a/server/mock/mock_test.go b/server/mock/mock_test.go new file mode 100644 index 00000000..d910af1a --- /dev/null +++ b/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) + } +}