Increase coverage

asserter/asserter_test.go

@@ -271,4 +271,29 @@ func TestNew(t *testing.T) {
 			assert.ElementsMatch(t, test.networkOptions.Allow.Errors, errors)
 		})
 	}
+
+	t.Run("non-existent file", func(t *testing.T) {
+		asserter, err := NewClientWithFile(
+			"blah",
+		)
+		assert.Error(t, err)
+		assert.Nil(t, asserter)
+	})
+
+	t.Run("file not formatted correctly", func(t *testing.T) {
+		tmpfile, err := ioutil.TempFile("", "test.json")
+		assert.NoError(t, err)
+		defer os.Remove(tmpfile.Name())
+
+		_, err = tmpfile.Write([]byte("blah"))
+		assert.NoError(t, err)
+		assert.NoError(t, tmpfile.Close())
+
+		asserter, err := NewClientWithFile(
+			tmpfile.Name(),
+		)
+
+		assert.Nil(t, asserter)
+		assert.Error(t, err)
+	})
 }

asserter/request.go

@@ -35,7 +35,7 @@ func SupportedNetworks(supportedNetworks []*types.NetworkIdentifier) error {
 		}
 
 		if containsNetworkIdentifier(parsed, network) {
-			return fmt.Errorf("supported network duplicate %+v", *network)
+			return fmt.Errorf("supported network duplicate %+v", network)
 		}
 		parsed[i] = network
 	}
@@ -210,6 +210,10 @@ func (a *Asserter) MempoolRequest(request *types.MempoolRequest) error {
 // MempoolTransactionRequest ensures that a types.MempoolTransactionRequest
 // is well-formatted.
 func (a *Asserter) MempoolTransactionRequest(request *types.MempoolTransactionRequest) error {
+	if a == nil {
+		return ErrAsserterNotInitialized
+	}
+
 	if request == nil {
 		return errors.New("MempoolTransactionRequest is nil")
 	}

asserter/request_test.go

@@ -55,6 +55,47 @@ var (
 	}
 )
 
+func TestSupportedNetworks(t *testing.T) {
+	var tests = map[string]struct {
+		networks []*types.NetworkIdentifier
+
+		err error
+	}{
+		"valid networks": {
+			networks: []*types.NetworkIdentifier{
+				validNetworkIdentifier,
+				wrongNetworkIdentifier,
+			},
+			err: nil,
+		},
+		"no valid networks": {
+			networks: []*types.NetworkIdentifier{},
+			err:      errors.New("no supported networks"),
+		},
+		"invalid network": {
+			networks: []*types.NetworkIdentifier{
+				{
+					Blockchain: "blah",
+				},
+			},
+			err: errors.New("NetworkIdentifier.Network is missing"),
+		},
+		"duplicate networks": {
+			networks: []*types.NetworkIdentifier{
+				validNetworkIdentifier,
+				validNetworkIdentifier,
+			},
+			err: fmt.Errorf("supported network duplicate %+v", validNetworkIdentifier),
+		},
+	}
+
+	for name, test := range tests {
+		t.Run(name, func(t *testing.T) {
+			assert.Equal(t, test.err, SupportedNetworks(test.networks))
+		})
+	}
+}
+
 func TestAccountBalanceRequest(t *testing.T) {
 	var tests = map[string]struct {
 		request *types.AccountBalanceRequest