git.r.bdr.sh - rbdr/mobius/blob - hotline/server_blackbox_test.go

   1 package hotline
   2
   3 import (
   4         "bytes"
   5         "context"
   6         "fmt"
   7         "go.uber.org/zap"
   8         "go.uber.org/zap/zapcore"
   9         "net"
  10         "os"
  11         "reflect"
  12         "testing"
  13 )
  14
  15 type testCase struct {
  16         name        string       // test case description
  17         account     Account      // Account struct for a user that will test transaction will execute under
  18         request     *Transaction // transaction that will be sent by the client to the server
  19         setup       func()       // Optional test-specific setup required for the scenario
  20         teardown    func()       // Optional test-specific teardown for the scenario
  21         mockHandler map[int]*mockClientHandler
  22 }
  23
  24 func (tt *testCase) Setup(srv *Server) error {
  25         if err := srv.NewUser(tt.account.Login, tt.account.Name, NegatedUserString([]byte(tt.account.Password)), *tt.account.Access); err != nil {
  26                 return err
  27         }
  28
  29         if tt.setup != nil {
  30                 tt.setup()
  31         }
  32
  33         return nil
  34 }
  35
  36 func (tt *testCase) Teardown(srv *Server) error {
  37         if err := srv.DeleteUser(tt.account.Login); err != nil {
  38                 return err
  39         }
  40
  41         if tt.teardown != nil {
  42                 tt.teardown()
  43         }
  44
  45         return nil
  46 }
  47
  48 func NewTestLogger() *zap.SugaredLogger {
  49         encoderCfg := zap.NewProductionEncoderConfig()
  50         encoderCfg.TimeKey = "timestamp"
  51         encoderCfg.EncodeTime = zapcore.ISO8601TimeEncoder
  52
  53         core := zapcore.NewCore(
  54                 zapcore.NewConsoleEncoder(encoderCfg),
  55                 zapcore.Lock(os.Stdout),
  56                 zap.DebugLevel,
  57         )
  58
  59         cores := []zapcore.Core{core}
  60         l := zap.New(zapcore.NewTee(cores...))
  61         defer func() { _ = l.Sync() }()
  62         return l.Sugar()
  63 }
  64
  65 func StartTestServer() (*Server, context.Context, context.CancelFunc) {
  66         ctx, cancelRoot := context.WithCancel(context.Background())
  67
  68         srv, err := NewServer("test/config/", "localhost", 0, NewTestLogger())
  69         if err != nil {
  70                 panic(err)
  71         }
  72
  73         go func() {
  74                 err := srv.ListenAndServe(ctx, cancelRoot)
  75                 if err != nil {
  76                         panic(err)
  77                 }
  78         }()
  79
  80         return srv, ctx, cancelRoot
  81 }
  82
  83 func TestHandshake(t *testing.T) {
  84         srv, _, cancelFunc := StartTestServer()
  85         defer cancelFunc()
  86
  87         port := srv.APIListener.Addr().(*net.TCPAddr).Port
  88
  89         conn, err := net.Dial("tcp", fmt.Sprintf(":%v", port))
  90         if err != nil {
  91                 t.Fatal(err)
  92         }
  93         defer conn.Close()
  94
  95         conn.Write([]byte{0x54, 0x52, 0x54, 0x50, 0x00, 0x01, 0x00, 0x00})
  96
  97         replyBuf := make([]byte, 8)
  98         _, _ = conn.Read(replyBuf)
  99
 100         want := []byte{84, 82, 84, 80, 0, 0, 0, 0}
 101         if bytes.Compare(replyBuf, want) != 0 {
 102                 t.Errorf("%q, want %q", replyBuf, want)
 103         }
 104
 105 }
 106
 107 //func TestLogin(t *testing.T) {
 108 //
 109 //      tests := []struct {
 110 //              name   string
 111 //              client *Client
 112 //      }{
 113 //              {
 114 //                      name:   "when login is successful",
 115 //                      client: NewClient("guest", NewTestLogger()),
 116 //              },
 117 //      }
 118 //      for _, test := range tests {
 119 //              t.Run(test.name, func(t *testing.T) {
 120 //
 121 //              })
 122 //      }
 123 //}
 124
 125
 126 func TestNewUser(t *testing.T) {
 127         srv, _, _ := StartTestServer()
 128
 129         tests := []testCase{
 130                 //{
 131                 //      name: "a valid new account",
 132                 //      mockHandler: func() mockClientHandler {
 133                 //              mh := mockClientHandler{}
 134                 //              mh.On("Handle", mock.AnythingOfType("*hotline.Client"), mock.MatchedBy(func(t *Transaction) bool {
 135                 //                      println("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@")
 136                 //                      spew.Dump(t.Type)
 137                 //                      spew.Dump(bytes.Equal(t.Type, []byte{0x01, 0x5e}))
 138                 //                      //if !bytes.Equal(t.GetField(fieldError).Data, []byte("You are not allowed to create new accounts.")) {
 139                 //                      //      return false
 140                 //                      //}
 141                 //                      return bytes.Equal(t.Type, []byte{0x01, 0x5e},
 142                 //                      )
 143                 //              })).Return(
 144                 //                      []Transaction{}, nil,
 145                 //              )
 146                 //
 147                 //              clientHandlers[tranNewUser] = mh
 148                 //              return mh
 149                 //      }(),
 150                 //      client: func() *Client {
 151                 //              c := NewClient("testUser", NewTestLogger())
 152                 //              return c
 153                 //      }(),
 154                 //      teardown: func() {
 155                 //              _ = srv.DeleteUser("testUser")
 156                 //      },
 157                 //      account: Account{
 158                 //              Login:    "test",
 159                 //              Name:     "unnamed",
 160                 //              Password: "test",
 161                 //              Access:   &[]byte{255, 255, 255, 255, 255, 255, 255, 255},
 162                 //      },
 163                 //      request: NewTransaction(
 164                 //              tranNewUser, nil,
 165                 //              NewField(fieldUserLogin, []byte(NegatedUserString([]byte("testUser")))),
 166                 //              NewField(fieldUserName, []byte("testUserName")),
 167                 //              NewField(fieldUserPassword, []byte(NegatedUserString([]byte("testPw")))),
 168                 //              NewField(fieldUserAccess, []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}),
 169                 //      ),
 170                 //      want: &Transaction{
 171                 //              Fields: []Field{},
 172                 //      },
 173                 //},
 174                 //{
 175                 //      name: "a newUser request from a user without the required access",
 176                 //      mockHandler: func() *mockClientHandler {
 177                 //              mh := mockClientHandler{}
 178                 //              mh.On("Handle", mock.AnythingOfType("*hotline.Client"), mock.MatchedBy(func(t *Transaction) bool {
 179                 //                      if !bytes.Equal(t.GetField(fieldError).Data, []byte("You are not allowed to create new accounts.")) {
 180                 //                              return false
 181                 //                      }
 182                 //                      return bytes.Equal(t.Type, []byte{0x01, 0x5e})
 183                 //              })).Return(
 184                 //                      []Transaction{}, nil,
 185                 //              )
 186                 //              return &mh
 187                 //      }(),
 188                 //      teardown: func() {
 189                 //              _ = srv.DeleteUser("testUser")
 190                 //      },
 191                 //      account: Account{
 192                 //              Login:    "test",
 193                 //              Name:     "unnamed",
 194                 //              Password: "test",
 195                 //              Access:   &[]byte{0, 0, 0, 0, 0, 0, 0, 0},
 196                 //      },
 197                 //      request: NewTransaction(
 198                 //              tranNewUser, nil,
 199                 //              NewField(fieldUserLogin, []byte(NegatedUserString([]byte("testUser")))),
 200                 //              NewField(fieldUserName, []byte("testUserName")),
 201                 //              NewField(fieldUserPassword, []byte(NegatedUserString([]byte("testPw")))),
 202                 //              NewField(fieldUserAccess, []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}),
 203                 //      ),
 204                 //},
 205                 //{
 206                 //      name: "when user does not have required permission",
 207                 //      mockHandler: func() map[int]*mockClientHandler {
 208                 //              mockHandlers := make(map[int]*mockClientHandler)
 209                 //
 210                 //              mh := mockClientHandler{}
 211                 //              mh.On("Handle", mock.AnythingOfType("*hotline.Client"), mock.MatchedBy(func(t *Transaction) bool {
 212                 //                      return t.equal(Transaction{
 213                 //                              Type:      []byte{0x01, 0x5e},
 214                 //                              IsReply:   1,
 215                 //                              ErrorCode: []byte{0, 0, 0, 1},
 216                 //                              Fields: []Field{
 217                 //                                      NewField(fieldError, []byte("You are not allowed to create new accounts.")),
 218                 //                              },
 219                 //                      })
 220                 //              })).Return(
 221                 //                      []Transaction{}, nil,
 222                 //              )
 223                 //              mockHandlers[tranNewUser] = &mh
 224                 //
 225                 //              return mockHandlers
 226                 //      }(),
 227                 //
 228                 //      teardown: func() {
 229                 //              _ = srv.DeleteUser("testUser")
 230                 //      },
 231                 //      account: Account{
 232                 //              Login:    "test",
 233                 //              Name:     "unnamed",
 234                 //              Password: "test",
 235                 //              Access:   &[]byte{0, 0, 0, 0, 0, 0, 0, 0},
 236                 //      },
 237                 //      request: NewTransaction(
 238                 //              tranNewUser, nil,
 239                 //              NewField(fieldUserLogin, []byte(NegatedUserString([]byte("testUser")))),
 240                 //              NewField(fieldUserName, []byte("testUserName")),
 241                 //              NewField(fieldUserPassword, []byte(NegatedUserString([]byte("testPw")))),
 242                 //              NewField(fieldUserAccess, []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}),
 243                 //      ),
 244                 //},
 245
 246                 //{
 247                 //      name: "a request to create a user that already exists",
 248                 //      setup: func() {
 249                 //
 250                 //      },
 251                 //      teardown: func() {
 252                 //              _ = srv.DeleteUser("testUser")
 253                 //      },
 254                 //      account: Account{
 255                 //              Login:    "test",
 256                 //              Name:     "unnamed",
 257                 //              Password: "test",
 258                 //              Access:   &[]byte{255, 255, 255, 255, 255, 255, 255, 255},
 259                 //      },
 260                 //      request: NewTransaction(
 261                 //              tranNewUser, nil,
 262                 //              NewField(fieldUserLogin, []byte(NegatedUserString([]byte("guest")))),
 263                 //              NewField(fieldUserName, []byte("testUserName")),
 264                 //              NewField(fieldUserPassword, []byte(NegatedUserString([]byte("testPw")))),
 265                 //              NewField(fieldUserAccess, []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}),
 266                 //      ),
 267                 //      want: &Transaction{
 268                 //              Fields: []Field{
 269                 //                      NewField(fieldError, []byte("Cannot create account guest because there is already an account with that login.")),
 270                 //              },
 271                 //      },
 272                 //},
 273         }
 274
 275         for _, test := range tests {
 276                 t.Run(test.name, func(t *testing.T) {
 277                         test.Setup(srv)
 278
 279                         // move to Setup?
 280                         c := NewClient(test.account.Name, NewTestLogger())
 281                         err := c.JoinServer(fmt.Sprintf(":%v", srv.APIPort()), test.account.Login, test.account.Password)
 282                         if err != nil {
 283                                 t.Errorf("login failed: %v", err)
 284                         }
 285                         // end move to Setup??
 286
 287                         for key, value := range test.mockHandler {
 288                                 c.Handlers[uint16(key)] = value
 289                         }
 290
 291                         // send test case request
 292                         _ = c.Send(*test.request)
 293
 294                         //time.Sleep(1 * time.Second)
 295                         // ===
 296
 297                         transactions, _ := readN(c.Connection, 1)
 298                         for _, t := range transactions {
 299                                 _ = c.HandleTransaction(&t)
 300                         }
 301
 302                         // ===
 303
 304                         for _, handler := range test.mockHandler {
 305                                 handler.AssertExpectations(t)
 306                         }
 307
 308                         test.Teardown(srv)
 309                 })
 310         }
 311 }
 312
 313
 314
 315 // equal is a utility function used only in tests that determines if transactions are equal enough
 316 func (t Transaction) equal(otherT Transaction) bool {
 317         t.ID = []byte{0, 0, 0, 0}
 318         otherT.ID = []byte{0, 0, 0, 0}
 319
 320         t.TotalSize = []byte{0, 0, 0, 0}
 321         otherT.TotalSize = []byte{0, 0, 0, 0}
 322
 323         t.DataSize = []byte{0, 0, 0, 0}
 324         otherT.DataSize = []byte{0, 0, 0, 0}
 325
 326         t.ParamCount = []byte{0, 0}
 327         otherT.ParamCount = []byte{0, 0}
 328
 329         //spew.Dump(t)
 330         //spew.Dump(otherT)
 331
 332         return reflect.DeepEqual(t, otherT)
 333 }