github.com/glide-im/glide@v1.6.0/pkg/subscription/subscription_impl/chan_test.go (about)

     1  package subscription_impl
     2  
     3  import (
     4  	"github.com/glide-im/glide/pkg/gate"
     5  	"github.com/glide-im/glide/pkg/messages"
     6  	"github.com/glide-im/glide/pkg/subscription"
     7  	"github.com/stretchr/testify/assert"
     8  	"testing"
     9  	"time"
    10  )
    11  
    12  var normalOpts = &SubscriberOptions{
    13  	Perm: PermWrite | PermRead,
    14  }
    15  
    16  func mockNewChannel(id subscription.ChanID) *Channel {
    17  	channel, _ := NewChannel(id, &mockGate{}, &mockStore{}, &mockSeqStore{})
    18  	return channel
    19  }
    20  
    21  type mockGate struct {
    22  }
    23  
    24  func (m mockGate) SetClientID(old gate.ID, new_ gate.ID) error {
    25  	//TODO implement me
    26  	panic("implement me")
    27  }
    28  
    29  func (m mockGate) UpdateClient(id gate.ID, info *gate.ClientSecrets) error {
    30  	//TODO implement me
    31  	panic("implement me")
    32  }
    33  
    34  func (m mockGate) ExitClient(id gate.ID) error {
    35  	//TODO implement me
    36  	panic("implement me")
    37  }
    38  
    39  func (m mockGate) GetClient(id gate.ID) gate.Client {
    40  	//TODO implement me
    41  	panic("implement me")
    42  }
    43  
    44  func (m mockGate) GetAll() map[gate.ID]gate.Info {
    45  	//TODO implement me
    46  	panic("implement me")
    47  }
    48  
    49  func (m mockGate) SetMessageHandler(h gate.MessageHandler) {
    50  	//TODO implement me
    51  	panic("implement me")
    52  }
    53  
    54  func (m mockGate) AddClient(cs gate.Client) {
    55  	//TODO implement me
    56  	panic("implement me")
    57  }
    58  
    59  func (m mockGate) EnqueueMessage(gate.ID, *messages.GlideMessage) error {
    60  	return nil
    61  }
    62  
    63  type message struct{}
    64  
    65  func (*message) GetFrom() subscription.SubscriberID {
    66  	return ""
    67  }
    68  
    69  type mockSeqStore struct {
    70  	segmentLen int64
    71  	nextSeq    int64
    72  }
    73  
    74  func (m *mockSeqStore) NextSegmentSequence(subscription.ChanID, subscription.ChanInfo) (int64, int64, error) {
    75  	seq := m.nextSeq
    76  	m.nextSeq = seq + m.segmentLen
    77  	return seq, m.segmentLen, nil
    78  }
    79  
    80  func TestGroup_Publish(t *testing.T) {
    81  	channel := mockNewChannel("test")
    82  	err2 := channel.Subscribe("test", normalOpts)
    83  	assert.NoError(t, err2)
    84  	msg := &PublishMessage{
    85  		From:    "test",
    86  		Type:    TypeNotify,
    87  		Message: &messages.GlideMessage{},
    88  	}
    89  	err := channel.Publish(msg)
    90  	assert.NoError(t, err)
    91  	err = channel.Publish(msg)
    92  	assert.NoError(t, err)
    93  	err = channel.Publish(msg)
    94  	assert.NoError(t, err)
    95  	time.Sleep(time.Millisecond * 50)
    96  }
    97  
    98  func TestChannel_Sleep(t *testing.T) {
    99  	channel := mockNewChannel("test")
   100  	err2 := channel.Subscribe("test", normalOpts)
   101  	assert.NoError(t, err2)
   102  	msg := &PublishMessage{
   103  		From:    "test",
   104  		Type:    TypeNotify,
   105  		Message: &messages.GlideMessage{},
   106  	}
   107  	go func() {
   108  		for i := 0; i < 100; i++ {
   109  			time.Sleep(time.Millisecond * 50)
   110  			_ = channel.Publish(msg)
   111  		}
   112  	}()
   113  
   114  	time.Sleep(time.Millisecond * 50)
   115  }
   116  
   117  func TestChannel_PublishErr(t *testing.T) {
   118  	channel := mockNewChannel("test")
   119  
   120  	// invalid type
   121  	err := channel.Publish(&PublishMessage{})
   122  	assert.Error(t, err)
   123  
   124  	// permission denied
   125  	err = channel.Subscribe("t", &SubscriberOptions{Perm: PermRead})
   126  	assert.NoError(t, err)
   127  	err = channel.Publish(&PublishMessage{From: "t"})
   128  	assert.Error(t, err)
   129  
   130  	// muted
   131  	channel.info.Muted = true
   132  	err = channel.Publish(&PublishMessage{From: "t"})
   133  	assert.Error(t, err)
   134  }
   135  
   136  func TestGroup_PublishUnknownType(t *testing.T) {
   137  	group := mockNewChannel("test")
   138  	err := group.Publish(&PublishMessage{})
   139  	assert.EqualError(t, err, errUnknownMessageType)
   140  }
   141  
   142  func TestGroup_PublishUnexpectedMessageType(t *testing.T) {
   143  	group := mockNewChannel("test")
   144  	err := group.Publish(&PublishMessage{})
   145  	assert.Error(t, err)
   146  }
   147  
   148  func TestChannel_nextSeq(t *testing.T) {
   149  	m := &mockSeqStore{
   150  		segmentLen: 4,
   151  		nextSeq:    0,
   152  	}
   153  	channel, err := NewChannel("test", nil, nil, m)
   154  	assert.NoError(t, err)
   155  
   156  	for i := 1; i < 20; i++ {
   157  		seq, err := channel.nextSeq()
   158  		assert.NoError(t, err)
   159  		assert.Equal(t, int64(i), seq)
   160  	}
   161  }
   162  
   163  func TestChannel_Subscribe(t *testing.T) {
   164  	channel := mockNewChannel("test")
   165  	err := channel.Subscribe("sb_test", normalOpts)
   166  	assert.NoError(t, err)
   167  }
   168  
   169  func TestChannel_SubscribeUpdate(t *testing.T) {
   170  	channel := mockNewChannel("test")
   171  	err := channel.Subscribe("sb_test", normalOpts)
   172  	assert.NoError(t, err)
   173  	err = channel.Subscribe("sb_test", &SubscriberOptions{Perm: PermNone})
   174  	assert.NoError(t, err)
   175  	assert.Equal(t, channel.subscribers["sb_test"].Perm, PermNone)
   176  }
   177  
   178  func TestChannel_Unsubscribe(t *testing.T) {
   179  	channel := mockNewChannel("test")
   180  	err := channel.Subscribe("sb_test", normalOpts)
   181  	assert.NoError(t, err)
   182  	err = channel.Unsubscribe("sb_test")
   183  	assert.NoError(t, err)
   184  	err = channel.Unsubscribe("sb_test")
   185  	assert.EqualError(t, err, subscription.ErrNotSubscribed)
   186  }
   187  
   188  func TestChannel_Update(t *testing.T) {
   189  	channel := mockNewChannel("test")
   190  	err := channel.Update(&subscription.ChanInfo{Blocked: false, Muted: true})
   191  	assert.NoError(t, err)
   192  	assert.Equal(t, channel.info.Blocked, false)
   193  	assert.Equal(t, channel.info.Muted, true)
   194  }
   195  
   196  func TestChannel_Close(t *testing.T) {
   197  	channel := mockNewChannel("test")
   198  	err := channel.Subscribe("t", normalOpts)
   199  	assert.NoError(t, err)
   200  	err = channel.Close()
   201  	assert.NoError(t, err)
   202  	err = channel.Publish(&PublishMessage{From: "t", Type: TypeMessage})
   203  	assert.Error(t, err)
   204  }