Improve state test.

State/state.go

@@ -19,20 +19,10 @@ const (
 	CreateAsAnnounce
 )
 
-// NewState : Create new RelayState instance with redis client
-func NewState(redisClient *redis.Client, notify bool) RelayState {
-	var config RelayState
-	config.RedisClient = redisClient
-	config.notify = notify
-
-	config.Load()
-	return config
-}
-
 // RelayState : Store subscriptions and relay configrations
 type RelayState struct {
 	RedisClient *redis.Client
-	notify      bool
+	notifiable  bool
 
 	RelayConfig    relayConfig    `json:"relayConfig,omitempty"`
 	LimitedDomains []string       `json:"limitedDomains,omitempty"`
@@ -40,17 +30,31 @@ type RelayState struct {
 	Subscriptions  []Subscription `json:"subscriptions,omitempty"`
 }
 
-func (config *RelayState) ListenNotify() {
+// NewState : Create new RelayState instance with redis client
-	go func() {
+func NewState(redisClient *redis.Client, notifiable bool) RelayState {
-		_, err := config.RedisClient.Subscribe("relay_refresh").Receive()
+	var config RelayState
-		if err != nil {
+	config.RedisClient = redisClient
-			panic(err)
+	config.notifiable = notifiable
-		}
-		ch := config.RedisClient.Subscribe("relay_refresh").Channel()
 
+	config.Load()
+	return config
+}
+
+func (config *RelayState) ListenNotify(c chan<- bool) {
+	_, err := config.RedisClient.Subscribe("relay_refresh").Receive()
+	if err != nil {
+		panic(err)
+	}
+	ch := config.RedisClient.Subscribe("relay_refresh").Channel()
+
+	cNotify := c != nil
+	go func() {
 		for range ch {
 			fmt.Println("Config refreshed from state changed notify.")
 			config.Load()
+			if cNotify {
+				c <- true
+			}
 		}
 	}()
 }
@@ -102,11 +106,8 @@ func (config *RelayState) SetConfig(key Config, value bool) {
 	case CreateAsAnnounce:
 		config.RedisClient.HSet("relay:config", "create_as_announce", strValue).Result()
 	}
-	if config.notify {
+
-		config.RedisClient.Publish("relay_refresh", "Config refreshing request.")
+	config.refresh()
-	} else {
-		config.Load()
-	}
 }
 
 // AddSubscription : Add new instance for subscription list
@@ -117,11 +118,7 @@ func (config *RelayState) AddSubscription(domain Subscription) {
 		"actor_id":    domain.ActorID,
 	})
 
-	if config.notify {
+	config.refresh()
-		config.RedisClient.Publish("relay_refresh", "Config refreshing request.")
-	} else {
-		config.Load()
-	}
 }
 
 // DelSubscription : Delete instance from subscription list
@@ -129,11 +126,7 @@ func (config *RelayState) DelSubscription(domain string) {
 	config.RedisClient.Del("relay:subscription:" + domain).Result()
 	config.RedisClient.Del("relay:pending:" + domain).Result()
 
-	if config.notify {
+	config.refresh()
-		config.RedisClient.Publish("relay_refresh", "Config refreshing request.")
-	} else {
-		config.Load()
-	}
 }
 
 // SelectSubscription : Select instance from string
@@ -154,11 +147,7 @@ func (config *RelayState) SetBlockedDomain(domain string, value bool) {
 		config.RedisClient.HDel("relay:config:blockedDomain", domain).Result()
 	}
 
-	if config.notify {
+	config.refresh()
-		config.RedisClient.Publish("relay_refresh", "Config refreshing request.")
-	} else {
-		config.Load()
-	}
 }
 
 // SetLimitedDomain : Set/Unset instance for limited domain
@@ -169,7 +158,11 @@ func (config *RelayState) SetLimitedDomain(domain string, value bool) {
 		config.RedisClient.HDel("relay:config:limitedDomain", domain).Result()
 	}
 
-	if config.notify {
+	config.refresh()
+}
+
+func (config *RelayState) refresh() {
+	if config.notifiable {
 		config.RedisClient.Publish("relay_refresh", "Config refreshing request.")
 	} else {
 		config.Load()

State/state_test.go

@@ -30,7 +30,7 @@ func TestMain(m *testing.M) {
 	redisClient.FlushAll().Result()
 }
 
-func TestInitialLoad(t *testing.T) {
+func TestLoadEmpty(t *testing.T) {
 	redisClient.FlushAll().Result()
 	testState := NewState(redisClient, false)
 
@@ -47,74 +47,58 @@ func TestInitialLoad(t *testing.T) {
 	redisClient.FlushAll().Result()
 }
 
-func TestAddLimited(t *testing.T) {
+func TestSetConfig(t *testing.T) {
+	ch := make(chan bool)
 	redisClient.FlushAll().Result()
-	testState := NewState(redisClient, false)
+	testState := NewState(redisClient, true)
+	testState.ListenNotify(ch)
 
-	testState.SetLimitedDomain("example.com", true)
+	testState.SetConfig(BlockService, true)
-
+	<-ch
-	valid := false
+	if testState.RelayConfig.BlockService != true {
-	for _, domain := range testState.LimitedDomains {
+		t.Fatalf("Failed enable config.")
-		if domain == "example.com" {
-			valid = true
-		}
 	}
-	if !valid {
+	testState.SetConfig(CreateAsAnnounce, true)
-		t.Fatalf("Failed write config.")
+	<-ch
+	if testState.RelayConfig.CreateAsAnnounce != true {
+		t.Fatalf("Failed enable config.")
+	}
+	testState.SetConfig(ManuallyAccept, true)
+	<-ch
+	if testState.RelayConfig.ManuallyAccept != true {
+		t.Fatalf("Failed enable config.")
 	}
 
-	testState.SetLimitedDomain("example.com", false)
+	testState.SetConfig(BlockService, false)
-
+	<-ch
-	for _, domain := range testState.LimitedDomains {
+	if testState.RelayConfig.BlockService != false {
-		if domain == "example.com" {
+		t.Fatalf("Failed disable config.")
-			valid = false
-		}
 	}
-	if !valid {
+	testState.SetConfig(CreateAsAnnounce, false)
-		t.Fatalf("Failed write config.")
+	<-ch
+	if testState.RelayConfig.CreateAsAnnounce != false {
+		t.Fatalf("Failed disable config.")
+	}
+	testState.SetConfig(ManuallyAccept, false)
+	<-ch
+	if testState.RelayConfig.ManuallyAccept != false {
+		t.Fatalf("Failed disable config.")
 	}
 
 	redisClient.FlushAll().Result()
 }
 
-func TestAddBlocked(t *testing.T) {
+func TestTreatSubscriptionNotify(t *testing.T) {
+	ch := make(chan bool)
 	redisClient.FlushAll().Result()
-	testState := NewState(redisClient, false)
+	testState := NewState(redisClient, true)
-
+	testState.ListenNotify(ch)
-	testState.SetBlockedDomain("example.com", true)
-
-	valid := false
-	for _, domain := range testState.BlockedDomains {
-		if domain == "example.com" {
-			valid = true
-		}
-	}
-	if !valid {
-		t.Fatalf("Failed write config.")
-	}
-
-	testState.SetBlockedDomain("example.com", false)
-
-	for _, domain := range testState.BlockedDomains {
-		if domain == "example.com" {
-			valid = false
-		}
-	}
-	if !valid {
-		t.Fatalf("Failed write config.")
-	}
-
-	redisClient.FlushAll().Result()
-}
-
-func TestAddSubscription(t *testing.T) {
-	redisClient.FlushAll().Result()
-	testState := NewState(redisClient, false)
 
 	testState.AddSubscription(Subscription{
 		Domain:   "example.com",
 		InboxURL: "https://example.com/inbox",
 	})
+	<-ch
 
 	valid := false
 	for _, domain := range testState.Subscriptions {
@@ -127,6 +111,7 @@ func TestAddSubscription(t *testing.T) {
 	}
 
 	testState.DelSubscription("example.com")
+	<-ch
 
 	for _, domain := range testState.Subscriptions {
 		if domain.Domain == "example.com" {
@@ -140,6 +125,101 @@ func TestAddSubscription(t *testing.T) {
 	redisClient.FlushAll().Result()
 }
 
+func TestSelectDomain(t *testing.T) {
+	ch := make(chan bool)
+	redisClient.FlushAll().Result()
+	testState := NewState(redisClient, true)
+	testState.ListenNotify(ch)
+
+	exampleSubscription := Subscription{
+		Domain:   "example.com",
+		InboxURL: "https://example.com/inbox",
+	}
+
+	testState.AddSubscription(exampleSubscription)
+	<-ch
+
+	subscription := testState.SelectSubscription("example.com")
+	if *subscription != exampleSubscription {
+		t.Fatalf("Failed select domain.")
+	}
+
+	subscription = testState.SelectSubscription("example.org")
+	if subscription != nil {
+		t.Fatalf("Failed select domain.")
+	}
+
+	redisClient.FlushAll().Result()
+}
+
+func TestBlockedDomain(t *testing.T) {
+	ch := make(chan bool)
+	redisClient.FlushAll().Result()
+	testState := NewState(redisClient, true)
+	testState.ListenNotify(ch)
+
+	testState.SetBlockedDomain("example.com", true)
+	<-ch
+
+	valid := false
+	for _, domain := range testState.BlockedDomains {
+		if domain == "example.com" {
+			valid = true
+		}
+	}
+	if !valid {
+		t.Fatalf("Failed write config.")
+	}
+
+	testState.SetBlockedDomain("example.com", false)
+	<-ch
+
+	for _, domain := range testState.BlockedDomains {
+		if domain == "example.com" {
+			valid = false
+		}
+	}
+	if !valid {
+		t.Fatalf("Failed write config.")
+	}
+
+	redisClient.FlushAll().Result()
+}
+
+func TestLimitedDomain(t *testing.T) {
+	ch := make(chan bool)
+	redisClient.FlushAll().Result()
+	testState := NewState(redisClient, true)
+	testState.ListenNotify(ch)
+
+	testState.SetLimitedDomain("example.com", true)
+	<-ch
+
+	valid := false
+	for _, domain := range testState.LimitedDomains {
+		if domain == "example.com" {
+			valid = true
+		}
+	}
+	if !valid {
+		t.Fatalf("Failed write config.")
+	}
+
+	testState.SetLimitedDomain("example.com", false)
+	<-ch
+
+	for _, domain := range testState.LimitedDomains {
+		if domain == "example.com" {
+			valid = false
+		}
+	}
+	if !valid {
+		t.Fatalf("Failed write config.")
+	}
+
+	redisClient.FlushAll().Result()
+}
+
 func TestLoadCompatiSubscription(t *testing.T) {
 	redisClient.FlushAll().Result()
 	testState := NewState(redisClient, false)
@@ -164,36 +244,3 @@ func TestLoadCompatiSubscription(t *testing.T) {
 
 	redisClient.FlushAll().Result()
 }
-
-func TestSetConfig(t *testing.T) {
-	redisClient.FlushAll().Result()
-	testState := NewState(redisClient, false)
-
-	testState.SetConfig(BlockService, true)
-	if testState.RelayConfig.BlockService != true {
-		t.Fatalf("Failed enable config.")
-	}
-	testState.SetConfig(CreateAsAnnounce, true)
-	if testState.RelayConfig.CreateAsAnnounce != true {
-		t.Fatalf("Failed enable config.")
-	}
-	testState.SetConfig(ManuallyAccept, true)
-	if testState.RelayConfig.ManuallyAccept != true {
-		t.Fatalf("Failed enable config.")
-	}
-
-	testState.SetConfig(BlockService, false)
-	if testState.RelayConfig.BlockService != false {
-		t.Fatalf("Failed disable config.")
-	}
-	testState.SetConfig(CreateAsAnnounce, false)
-	if testState.RelayConfig.CreateAsAnnounce != false {
-		t.Fatalf("Failed disable config.")
-	}
-	testState.SetConfig(ManuallyAccept, false)
-	if testState.RelayConfig.ManuallyAccept != false {
-		t.Fatalf("Failed disable config.")
-	}
-
-	redisClient.FlushAll().Result()
-}

cli/cli_test.go

@@ -5,14 +5,12 @@ import (
 	"testing"
 
 	"github.com/spf13/viper"
-	state "github.com/yukimochi/Activity-Relay/State"
 )
 
 func TestMain(m *testing.M) {
 	viper.Set("actor_pem", "../misc/testKey.pem")
 	viper.Set("relay_domain", "relay.yukimochi.example.org")
 	initConfig()
-	relayState = state.NewState(relayState.RedisClient, false)
 
 	relayState.RedisClient.FlushAll().Result()
 	code := m.Run()

cli/config_test.go

@@ -24,6 +24,7 @@ func TestServiceBlock(t *testing.T) {
 		t.Fatalf("Not Disabled Blocking feature for service-type actor")
 	}
 }
+
 func TestManuallyAccept(t *testing.T) {
 	app := buildNewCmd()
 
@@ -40,6 +41,7 @@ func TestManuallyAccept(t *testing.T) {
 		t.Fatalf("Not Disabled Manually accept follow-request feature")
 	}
 }
+
 func TestCreateAsAnnounce(t *testing.T) {
 	app := buildNewCmd()
 
@@ -56,6 +58,7 @@ func TestCreateAsAnnounce(t *testing.T) {
 		t.Fatalf("Enable announce activity instead of relay create activity")
 	}
 }
+
 func TestInvalidConfig(t *testing.T) {
 	app := buildNewCmd()
 	buffer := new(bytes.Buffer)
@@ -115,6 +118,7 @@ func TestExportConfig(t *testing.T) {
 		t.Fatalf("Invalid Responce.")
 	}
 }
+
 func TestImportConfig(t *testing.T) {
 	app := buildNewCmd()
 

cli/domain.go

@@ -121,9 +121,9 @@ func unfollowDomains(cmd *cobra.Command, args []string) error {
 	for _, domain := range args {
 		if contains(subscriptions, domain) {
 			subscription := *relayState.SelectSubscription(domain)
-			cmd.Println("Unfollow [" + subscription.Domain + "]")
 			createUnfollowRequestResponse(subscription)
 			relayState.DelSubscription(subscription.Domain)
+			cmd.Println("Unfollow [" + subscription.Domain + "]")
 			break
 		} else {
 			cmd.Println("Invalid domain [" + domain + "] given")

main.go

@@ -59,7 +59,7 @@ func initConfig() {
 	}
 	redisClient := redis.NewClient(redisOption)
 	relayState = state.NewState(redisClient, true)
-	relayState.ListenNotify()
+	relayState.ListenNotify(nil)
 	machineryConfig := &config.Config{
 		Broker:          viper.GetString("redis_url"),
 		DefaultQueue:    "relay",