Ejemplo n.º 1
0
func TestSubscribe(t *testing.T) {
	h, err := newTestHub()
	assert.NoError(t, err)
	defer h.Close()

	assert.True(t, h.IsRunning(time.Millisecond))

	conn := NewMockConnection()

	/* register the connection and validate registered */
	err = h.Register(conn)
	assert.NoError(t, err)

	topic := &TestTopic{}
	/* Count the number of subscriptions */
	assert.EqualValues(t, 0, h.SubscriptionTopicCount())
	i, err := h.TopicConnectionCount(topic)
	assert.Error(t, err)
	assert.EqualValues(t, 0, i)

	/* add a subscription*/
	err = h.Subscribe(conn, topic, interfacehub.NewFilters(topic))
	assert.NoError(t, err)

	/* Count the number of subscriptions */
	assert.EqualValues(t, 1, h.SubscriptionTopicCount())
	i, err = h.TopicConnectionCount(topic)
	assert.NoError(t, err)
	assert.EqualValues(t, 1, i)

	/* re-add the subscription should fail and counts remain same*/
	err = h.Subscribe(conn, topic, interfacehub.NewFilters(topic))
	assert.Error(t, err)
	assert.EqualValues(t, 1, h.SubscriptionTopicCount())
	i, err = h.TopicConnectionCount(topic)
	assert.NoError(t, err)
	assert.EqualValues(t, 1, i)

	/* subscribe conn nil */
	err = h.Subscribe(nil, topic, interfacehub.NewFilters(topic))
	assert.Error(t, err)

	/* subscribe topic nil */
	err = h.Subscribe(conn, nil, interfacehub.NewFilters(nil))
	assert.Error(t, err)

	/* subscribe filters nil */
	topic2 := &TestTopic2{}
	err = h.Subscribe(conn, topic2, nil)
	assert.NoError(t, err)

	/* subscribe on closed */
	err = h.Close()
	assert.NoError(t, err)
	err = h.Subscribe(conn, topic, interfacehub.NewFilters(topic))
	assert.Error(t, err)
}
Ejemplo n.º 2
0
func TestNewFilters(t *testing.T) {
	topic := &TestTopic{}
	f := interfacehub.NewFilters(topic)

	assert.IsType(t, &interfacehub.Filters{}, f)
	assert.Equal(t, topic, f.Topic())

}
Ejemplo n.º 3
0
func TestTopicConnectionCount(t *testing.T) {
	h, err := newTestHub()
	assert.NoError(t, err)
	defer h.Close()

	assert.True(t, h.IsRunning(time.Millisecond))

	conn := NewMockConnection()

	/* register the connection and validate registered */
	err = h.Register(conn)
	assert.NoError(t, err)

	/* Count the number of subscriptions */
	assert.EqualValues(t, 0, h.SubscriptionTopicCount())
	i, err := h.TopicConnectionCount(TestTopic{})
	assert.Error(t, err)
	assert.EqualValues(t, 0, i)

	/* add a subscription*/
	topic := &TestTopic{}
	err = h.Subscribe(conn, topic, interfacehub.NewFilters(topic))
	assert.NoError(t, err)

	/* Re-count the number of subscriptions */
	assert.EqualValues(t, 1, h.SubscriptionTopicCount())
	i, err = h.TopicConnectionCount(topic)
	assert.NoError(t, err)
	assert.EqualValues(t, 1, i)

	/* count nil topic */
	i, err = h.TopicConnectionCount(nil)
	assert.Error(t, err)
	assert.EqualValues(t, 0, i)

}
Ejemplo n.º 4
0
func TestPublish(t *testing.T) {
	h, err := newTestHub()
	assert.NoError(t, err)
	defer h.Close()

	assert.True(t, h.IsRunning(time.Millisecond))

	conn := NewMockConnection()
	conn2 := NewMockConnection()

	/* register the connection and validate registered */
	err = h.Register(conn)
	assert.NoError(t, err)
	err = h.Register(conn2)
	assert.NoError(t, err)

	/* add a subscription*/
	topic := &TestPublishOutput{}
	err = h.Subscribe(conn, topic, interfacehub.NewFilters(topic))
	assert.NoError(t, err)
	err = h.Subscribe(conn2, topic, interfacehub.NewFilters(topic))
	assert.NoError(t, err)

	pubmsg := make(chan interface{}, 1)
	conn.SetSendDest(pubmsg)

	/* Publish something to and ensure conn don't see it*/
	msg := uniqueString()

	err = h.Publish(conn, &TestPublishOutput{msg: msg})
	assert.NoError(t, err)

	var i interface{}
	select {
	case i = <-pubmsg:
	case <-time.After(time.Millisecond):
	}

	assert.Nil(t, i)

	/* Publish something to and ensure conn does see it*/
	msg = uniqueString()

	err = h.Publish(conn2, &TestPublishOutput{msg: msg})
	assert.NoError(t, err)
	select {
	case i = <-pubmsg:
	case <-time.After(time.Millisecond):
	}

	assert.NotNil(t, i)

	if i != nil {
		p := i.(*TestPublishOutput)
		assert.EqualValues(t, p.msg, msg)
	}

	/* Publish something to delayed connections */
	conn.SetDelay(10 * time.Millisecond)
	err = h.Publish(conn2, &TestPublishOutput{msg: uniqueString()})
	assert.NoError(t, err)
	/* This should take too long and error */
	err = h.Publish(conn2, &TestPublishOutput{msg: uniqueString()})
	assert.Error(t, err)
	conn.SetDelay(time.Duration(0))
	/* conn should be unregistered */
	b, err := h.IsRegistered(conn)
	assert.NoError(t, err)
	assert.False(t, b)

	/* Publish to deregistered connection  */
	err = h.Publish(conn, &TestPublishOutput{msg: uniqueString()})
	assert.Error(t, err)

	/* re-register the connection and validate registered */
	conn = NewMockConnection()
	err = h.Register(conn)
	assert.NoError(t, err)

	/* Publish nil */
	err = h.Publish(conn, nil)
	assert.Error(t, err)

	/* Publish nil conn*/
	err = h.Publish(nil, &TestPublishOutput{msg: "Nothing!"})
	assert.Error(t, err)

	/* Publish to closed */
	err = h.Close()
	assert.NoError(t, err)
	err = h.Publish(conn, &TestPublishOutput{msg: "Hi Testy More!"})
	assert.Error(t, err)
}
Ejemplo n.º 5
0
func Example() {

	/* create a hub */
	hub, err := interfacehub.NewHub()
	if err != nil {
		log.Fatalf("Unable to create new hub: %s\n", err)
	}
	defer hub.Close()

	/* Done channel to shut stuff down*/
	Done := make(chan bool)

	/* create a client subscribe channel */
	cc := connector.NewIntegratedConnection("interfacehub example client", "Client Conn")
	cc.SetHub(hub)
	err = cc.Register()
	if err != nil {
		log.Fatalf("Unable to regoster client connection: %s\n", err)
	}

	/* Set up the filters for the client to listen on */
	csf := interfacehub.NewFilters(&ExampleServerOutput{})
	csf.Add(&filter.Equal{
		Description:     "Filter to accept specific messages",
		Field:           "Rejected",
		ActionOnMatch:   filter.FILTER_ACTION_DENY,
		ActionOnNoMatch: filter.FILTER_ACTION_CONTINUE,
		ExpectedValue:   true,
	})
	csf.Add(&filter.Equal{
		Description:     "Filter to reject empty messages and accept everything else",
		Field:           "UpperCaseMessage",
		ActionOnMatch:   filter.FILTER_ACTION_DENY,
		ActionOnNoMatch: filter.FILTER_ACTION_ACCEPT,
		ExpectedValue:   "",
	})

	/* set up a client to print the server output received */
	clientmsg := make(chan interface{}, 1)
	cc.SetSendDestination(clientmsg)

	/* have the client print out what it receives */
	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		defer wg.Done()
		for {
			select {
			case <-Done:
				return
			case i := <-clientmsg:
				v, ok := i.(*ExampleServerOutput)
				if !ok {
					log.Fatal("Expected ExampleServerOutput message")
				}
				fmt.Printf("Echo from server: %s\n", v.UpperCaseMessage)
			}
		}
	}()

	/* do our client subscription to listen for the server response */
	err = cc.Subscribe(&ExampleServerOutput{}, csf)
	if err != nil {
		log.Fatalf("Could not subscribe client: %s\n", err)
	}

	/* create a server subscribe channel */
	sc := connector.NewIntegratedConnection("interfacehub example server", "Server Conn")
	sc.SetHub(hub)
	sc.Register()

	/* set up a server channel to listen  */
	servermsg := make(chan interface{}, 1)
	sc.SetSendDestination(servermsg)

	/* have the server reflect back in upper case */
	wg.Add(1)
	go func(conn *connector.IntegratedConnection) {
		defer wg.Done()
		for {
			select {
			case <-Done:
				return
			case i := <-servermsg:
				v, ok := i.(*ExampleServerInput)
				if !ok {
					log.Fatal("Expected ServerOutput message")
					return
				}
				conn.Publish(&ExampleServerOutput{
					Rejected:         v.Reject,
					UpperCaseMessage: strings.ToUpper(v.Message),
				})
			}
		}
	}(sc)

	/* do our server subscription to listen for the client requests */
	err = sc.Subscribe(&ExampleServerInput{}, nil)
	if err != nil {
		log.Fatalf("Could not subscribe server: %s\n", err)
	}

	/* Send the message*s from the client connection */

	msg := "My client message"
	fmt.Printf("Client Sending to server: %s\n", msg)
	err = cc.Publish(&ExampleServerInput{
		Message: msg,
		Reject:  false,
	})
	if err != nil {
		log.Fatalf("Could not publish to server: %s\n", err)
	}

	time.Sleep(1 * time.Millisecond)

	msg = "Another to be rejected by filter client message"
	fmt.Printf("Client Sending to server: %s\n", msg)
	err = cc.Publish(&ExampleServerInput{
		Message: msg,
		Reject:  true,
	})
	if err != nil {
		log.Fatalf("Could not publish to server: %s\n", err)
	}

	time.Sleep(1 * time.Millisecond)

	msg = "Last client message"
	fmt.Printf("Client Sending to server: %s\n", msg)
	err = cc.Publish(&ExampleServerInput{
		Message: msg,
		Reject:  false,
	})
	if err != nil {
		log.Fatalf("Could not publish to server: %s\n", err)
	}

	time.Sleep(1 * time.Millisecond)

	Done <- true
	Done <- true

	wg.Wait()

	// Output:
	// Client Sending to server: My client message
	// Echo from server: MY CLIENT MESSAGE
	// Client Sending to server: Another to be rejected by filter client message
	// Client Sending to server: Last client message
	// Echo from server: LAST CLIENT MESSAGE
}
Ejemplo n.º 6
0
func TestClientServerEcho(t *testing.T) {

	/* create a hub */
	hub, _ := interfacehub.NewHub()
	defer hub.Close()

	/* create a client subscribe channel */
	cc := connector.NewIntegratedConnection("interfacehub Unit Tests", "Client Conn")
	cc.SetHub(hub)
	cc.Register()

	/* create a server subscribe channel */
	sc := connector.NewIntegratedConnection("interfacehub Unit Tests", "Server Conn")
	sc.SetHub(hub)
	sc.Register()

	/* set up a client to print the server output received */
	pubmsg := make(chan interface{}, 1)
	cc.SetSendDestination(pubmsg)

	/* Set up the filters for the client to listen on */
	csf := interfacehub.NewFilters(&ServerOutput{})
	csf.Add(&filter.Equal{
		Description:     "Filter to accept specific messages",   // Rule description
		Field:           "UpperCaseMessage",                     // Interface field to match on
		ActionOnMatch:   filter.FILTER_ACTION_ACCEPT,            // Action on match
		ActionOnNoMatch: filter.FILTER_ACTION_CONTINUE,          // Action on not match
		ExpectedValue:   "MESSAGE WE ALWAYS WANT EVEN REJECTED", // Value interface field must match

	})

	csf.Add(&filter.Equal{
		Description:     "Filter to reject tagged messages",
		Field:           "Rejected",
		ActionOnMatch:   filter.FILTER_ACTION_ACCEPT,
		ActionOnNoMatch: filter.FILTER_ACTION_CONTINUE,
		ExpectedValue:   false,
	})
	csf.Add(&filter.Equal{
		Description:     "Everything we want to reject",
		Field:           "UpperCaseMessage",
		ActionOnMatch:   filter.FILTER_ACTION_DENY,
		ActionOnNoMatch: filter.FILTER_ACTION_DENY,
		ExpectedValue:   "",
	})

	/* do our client subscription to listen for the server response*/
	err := cc.Subscribe(&ServerOutput{}, csf)
	assert.NoError(t, err)

	err = sc.Publish(&ServerOutput{
		UpperCaseMessage: "MESSAGE WE ALWAYS WANT EVEN REJECTED",
		Rejected:         true,
	})
	assert.NoError(t, err)

	var i interface{}
	select {
	case i = <-pubmsg:
		v, ok := i.(*ServerOutput)
		assert.True(t, ok)
		assert.Equal(t, "MESSAGE WE ALWAYS WANT EVEN REJECTED", v.UpperCaseMessage)
		assert.True(t, v.Rejected)
	case <-time.After(10 * time.Millisecond):
		assert.Fail(t, "Timeout waiting for ServerOutput message")
	}

	err = sc.Publish(&ServerOutput{
		UpperCaseMessage: "ANOTHER MESSAGE WE WANT IF NOT REJECTED",
		Rejected:         true,
	})
	assert.NoError(t, err)

	select {
	case i = <-pubmsg:
		v, ok := i.(*ServerOutput)
		assert.True(t, ok)
		assert.Equal(t, "Nothing", v.UpperCaseMessage)
	case <-time.After(10 * time.Millisecond):
	}

	err = sc.Publish(&ServerOutput{
		UpperCaseMessage: "ANOTHER MESSAGE WE WANT IF NOT REJECTED",
		Rejected:         false,
	})
	assert.NoError(t, err)

	select {
	case i = <-pubmsg:
		v, ok := i.(*ServerOutput)
		assert.True(t, ok)
		assert.Equal(t, "ANOTHER MESSAGE WE WANT IF NOT REJECTED", v.UpperCaseMessage)
		assert.False(t, v.Rejected)
	case <-time.After(10 * time.Millisecond):
		assert.Fail(t, "Timeout waiting for ServerOutput message")
	}
}
Ejemplo n.º 7
0
func TestUnsubscribeConnection(t *testing.T) {
	h, err := newTestHub()
	assert.NoError(t, err)
	defer h.Close()

	assert.True(t, h.IsRunning(time.Millisecond))

	conn := NewMockConnection()
	conn2 := NewMockConnection()
	conn3 := NewMockConnection()

	/* register the connection and validate registered */
	err = h.Register(conn)
	assert.NoError(t, err)
	err = h.Register(conn2)
	assert.NoError(t, err)

	/* add a subscription*/
	topic := &TestTopic{}
	err = h.Subscribe(conn, topic, interfacehub.NewFilters(topic))
	assert.NoError(t, err)

	/* add another subscription for same connection different topic*/
	topic3 := &TestTopic2{}
	err = h.Subscribe(conn, topic3, interfacehub.NewFilters(topic3))
	assert.NoError(t, err)

	/* add another subscription for different connection same topic */
	err = h.Subscribe(conn2, topic, interfacehub.NewFilters(topic))
	assert.NoError(t, err)

	/* add another subscription for different connection different topic */
	topic4 := &map[string]string{"key": "value"}
	err = h.Subscribe(conn2, topic4, interfacehub.NewFilters(topic4))
	assert.NoError(t, err)

	/* make sure subscriptions look like we expect */
	assert.EqualValues(t, 3, h.SubscriptionTopicCount())
	i, err := h.TopicConnectionCount(topic)
	assert.NoError(t, err)
	assert.EqualValues(t, 2, i)
	i, err = h.TopicConnectionCount(topic3)
	assert.NoError(t, err)
	assert.EqualValues(t, 1, i)
	i, err = h.TopicConnectionCount(topic4)
	assert.NoError(t, err)
	assert.EqualValues(t, 1, i)

	/* we have 2 subscriptions for conn and 2 subscriptions for conn2 - with overlap in topic */
	/* unsubscribe the whole connection conn */
	err = h.UnsubscribeConnection(conn)
	assert.NoError(t, err)

	/* recount */
	assert.EqualValues(t, 2, h.SubscriptionTopicCount())
	i, err = h.TopicConnectionCount(topic)
	assert.NoError(t, err)
	assert.EqualValues(t, 1, i)
	i, err = h.TopicConnectionCount(topic3)
	assert.Error(t, err)
	assert.EqualValues(t, 0, i)
	i, err = h.TopicConnectionCount(topic4)
	assert.NoError(t, err)
	assert.EqualValues(t, 1, i)

	/* removal of non existent connection */
	err = h.UnsubscribeConnection(conn3)
	assert.Error(t, err)

	/* unsubscribe conn nil */
	err = h.UnsubscribeConnection(nil)
	assert.Error(t, err)
	assert.EqualValues(t, 2, h.SubscriptionTopicCount())

	/* unsubscribe on closed */
	err = h.Close()
	assert.NoError(t, err)
	err = h.UnsubscribeConnection(conn)
	assert.Error(t, err)
	assert.EqualValues(t, 0, h.SubscriptionTopicCount())
}
Ejemplo n.º 8
0
func TestUnsubscribe(t *testing.T) {
	h, err := newTestHub()
	assert.NoError(t, err)
	defer h.Close()

	assert.True(t, h.IsRunning(time.Millisecond))

	conn := NewMockConnection()
	conn2 := NewMockConnection()

	/* register the connection and validate registered */
	err = h.Register(conn)
	assert.NoError(t, err)
	err = h.Register(conn2)
	assert.NoError(t, err)

	/* Count the number of subscriptions */
	assert.EqualValues(t, 0, h.SubscriptionTopicCount())
	i, err := h.TopicConnectionCount(TestTopic{})
	assert.Error(t, err)
	assert.EqualValues(t, 0, i)

	/* add a subscription*/
	topic := &TestTopic{}
	err = h.Subscribe(conn, topic, interfacehub.NewFilters(topic))
	assert.NoError(t, err)

	/* Re-count the number of subscriptions */
	assert.EqualValues(t, 1, h.SubscriptionTopicCount())
	i, err = h.TopicConnectionCount(topic)
	assert.NoError(t, err)
	assert.EqualValues(t, 1, i)

	/* add another subscription for same connection same topic*/
	topic2 := &TestTopic{}
	err = h.Subscribe(conn, topic2, interfacehub.NewFilters(topic2))
	assert.Error(t, err)
	assert.EqualValues(t, 1, h.SubscriptionTopicCount())
	i, err = h.TopicConnectionCount(topic)
	assert.NoError(t, err)
	assert.EqualValues(t, 1, i)
	i, err = h.TopicConnectionCount(topic2)
	assert.NoError(t, err)
	assert.EqualValues(t, 1, i)

	/* add another subscription for same connection different topic*/
	topic3 := &TestTopic2{}
	err = h.Subscribe(conn, topic3, interfacehub.NewFilters(topic3))
	assert.NoError(t, err)
	assert.EqualValues(t, 2, h.SubscriptionTopicCount())
	i, err = h.TopicConnectionCount(topic)
	assert.NoError(t, err)
	assert.EqualValues(t, 1, i)
	i, err = h.TopicConnectionCount(topic3)
	assert.NoError(t, err)
	assert.EqualValues(t, 1, i)

	/* add another subscription for different connection same topic */
	err = h.Subscribe(conn2, topic, interfacehub.NewFilters(topic))
	assert.NoError(t, err)
	assert.EqualValues(t, 2, h.SubscriptionTopicCount())
	i, err = h.TopicConnectionCount(topic)
	assert.NoError(t, err)
	assert.EqualValues(t, 2, i)

	/* add another subscription for different connection different topic */
	topic4 := &map[string]string{"key": "value"}
	err = h.Subscribe(conn2, topic4, interfacehub.NewFilters(topic4))
	assert.NoError(t, err)
	assert.EqualValues(t, 3, h.SubscriptionTopicCount())
	i, err = h.TopicConnectionCount(topic)
	assert.NoError(t, err)
	assert.EqualValues(t, 2, i)

	/* add another subscription with mismatched subscription topic and filters topic */
	/* add another subscription for different connection different topic */
	err = h.Subscribe(conn2, topic4, interfacehub.NewFilters(topic))
	assert.Error(t, err)
	assert.EqualValues(t, 3, h.SubscriptionTopicCount())
	i, err = h.TopicConnectionCount(topic)
	assert.NoError(t, err)
	assert.EqualValues(t, 2, i)

	/* remove the topic subscription*/
	err = h.Unsubscribe(conn, topic)
	assert.NoError(t, err)
	assert.EqualValues(t, 3, h.SubscriptionTopicCount())
	i, err = h.TopicConnectionCount(topic)
	assert.NoError(t, err)
	assert.EqualValues(t, 1, i)

	err = h.Unsubscribe(conn2, topic)
	assert.NoError(t, err)
	assert.EqualValues(t, 2, h.SubscriptionTopicCount())
	i, err = h.TopicConnectionCount(topic)
	assert.Error(t, err)
	assert.EqualValues(t, 0, i)

	/* removal of non existent subscription */
	err = h.Unsubscribe(conn2, topic)
	assert.Error(t, err)
	assert.EqualValues(t, 2, h.SubscriptionTopicCount())
	i, err = h.TopicConnectionCount(topic)
	assert.Error(t, err)
	assert.EqualValues(t, 0, i)

	/* remove the topic3 subscription*/
	err = h.Unsubscribe(conn, topic3)
	assert.NoError(t, err)
	assert.EqualValues(t, 1, h.SubscriptionTopicCount())
	i, err = h.TopicConnectionCount(topic3)
	assert.Error(t, err)
	assert.EqualValues(t, 0, i)

	/* remove the topic4 subscription*/
	err = h.Unsubscribe(conn2, topic4)
	assert.NoError(t, err)
	assert.EqualValues(t, 0, h.SubscriptionTopicCount())
	i, err = h.TopicConnectionCount(topic4)
	assert.Error(t, err)
	assert.EqualValues(t, 0, i)

	/* unsubscribe conn nil */
	err = h.Unsubscribe(nil, topic4)
	assert.Error(t, err)
	assert.EqualValues(t, 0, h.SubscriptionTopicCount())

	/* unsubscribe conn nil */
	err = h.Unsubscribe(conn, nil)
	assert.Error(t, err)
	assert.EqualValues(t, 0, h.SubscriptionTopicCount())

	/* unsubscribe on closed */
	err = h.Close()
	assert.NoError(t, err)
	err = h.Unsubscribe(conn, topic4)
	assert.Error(t, err)
	assert.EqualValues(t, 0, h.SubscriptionTopicCount())
}