From a08b5d51cfea79ac8ce6150fd30b48f3e01a34fc Mon Sep 17 00:00:00 2001 From: Konstantin Itskov Date: Mon, 27 Aug 2018 14:00:02 -0400 Subject: [PATCH] Add a bunch of default basic unittests to boost coverage --- rtcbundlepolicy.go | 13 ++++++++++ rtcbundlepolicy_test.go | 46 +++++++++++++++++++++++++++++++++ rtccertificate.go | 4 +-- rtcicecredentialtype.go | 11 ++++++++ rtcicecredentialtype_test.go | 44 ++++++++++++++++++++++++++++++++ rtcicetransportpolicy.go | 11 ++++++++ rtcicetransportpolicy_test.go | 44 ++++++++++++++++++++++++++++++++ rtcpeerconnection.go | 2 +- rtcpeerconnection_test.go | 6 ++--- rtcsdptype.go | 15 +++++++++++ rtcsdptype_test.go | 48 +++++++++++++++++++++++++++++++++++ rtcsignalingstate.go | 2 +- rtcsignalingstate_test.go | 14 +++++++--- 13 files changed, 250 insertions(+), 10 deletions(-) create mode 100644 rtcbundlepolicy_test.go create mode 100644 rtcicecredentialtype_test.go create mode 100644 rtcicetransportpolicy_test.go create mode 100644 rtcsdptype_test.go diff --git a/rtcbundlepolicy.go b/rtcbundlepolicy.go index 2678c01d..04ccaaf5 100644 --- a/rtcbundlepolicy.go +++ b/rtcbundlepolicy.go @@ -16,6 +16,19 @@ const ( RTCBundlePolicyMaxBundle ) +func NewRTCBundlePolicy(raw string) (unknown RTCBundlePolicy) { + switch raw { + case "balanced": + return RTCBundlePolicyBalanced + case "max-compat": + return RTCBundlePolicyMaxCompat + case "max-bundle": + return RTCBundlePolicyMaxBundle + default: + return unknown + } +} + func (t RTCBundlePolicy) String() string { switch t { case RTCBundlePolicyBalanced: diff --git a/rtcbundlepolicy_test.go b/rtcbundlepolicy_test.go new file mode 100644 index 00000000..05b4191e --- /dev/null +++ b/rtcbundlepolicy_test.go @@ -0,0 +1,46 @@ +package webrtc + +import ( + "github.com/stretchr/testify/assert" + "testing" +) + +func TestNewRTCBundlePolicy(t *testing.T) { + testCases := []struct { + policyString string + expectedPolicy RTCBundlePolicy + }{ + {"unknown", RTCBundlePolicy(Unknown)}, + {"balanced", RTCBundlePolicyBalanced}, + {"max-compat", RTCBundlePolicyMaxCompat}, + {"max-bundle", RTCBundlePolicyMaxBundle}, + } + + for i, testCase := range testCases { + assert.Equal(t, + NewRTCBundlePolicy(testCase.policyString), + testCase.expectedPolicy, + "testCase: %d %v", i, testCase, + ) + } +} + +func TestRTCBundlePolicy_String(t *testing.T) { + testCases := []struct { + policy RTCBundlePolicy + expectedString string + }{ + {RTCBundlePolicy(Unknown), "unknown"}, + {RTCBundlePolicyBalanced, "balanced"}, + {RTCBundlePolicyMaxCompat, "max-compat"}, + {RTCBundlePolicyMaxBundle, "max-bundle"}, + } + + for i, testCase := range testCases { + assert.Equal(t, + testCase.policy.String(), + testCase.expectedString, + "testCase: %d %v", i, testCase, + ) + } +} diff --git a/rtccertificate.go b/rtccertificate.go index ccbace07..745b770b 100644 --- a/rtccertificate.go +++ b/rtccertificate.go @@ -3,13 +3,13 @@ package webrtc import ( "crypto" "crypto/ecdsa" + "crypto/rand" "crypto/rsa" "crypto/x509" - "time" "crypto/x509/pkix" "encoding/hex" - "crypto/rand" "math/big" + "time" ) // RTCCertificate represents a x509Cert used to authenticate WebRTC communications. diff --git a/rtcicecredentialtype.go b/rtcicecredentialtype.go index 6a87ba7d..93a81f20 100644 --- a/rtcicecredentialtype.go +++ b/rtcicecredentialtype.go @@ -10,6 +10,17 @@ const ( RTCIceCredentialTypeOauth ) +func NewRTCIceCredentialType(raw string) (unknown RTCIceCredentialType) { + switch raw { + case "password": + return RTCIceCredentialTypePassword + case "oauth": + return RTCIceCredentialTypeOauth + default: + return unknown + } +} + func (t RTCIceCredentialType) String() string { switch t { case RTCIceCredentialTypePassword: diff --git a/rtcicecredentialtype_test.go b/rtcicecredentialtype_test.go new file mode 100644 index 00000000..8eda3b5f --- /dev/null +++ b/rtcicecredentialtype_test.go @@ -0,0 +1,44 @@ +package webrtc + +import ( + "github.com/stretchr/testify/assert" + "testing" +) + +func TestNewRTCIceCredentialType(t *testing.T) { + testCases := []struct { + credentialTypeString string + expectedCredentialType RTCIceCredentialType + }{ + {"unknown", RTCIceCredentialType(Unknown)}, + {"password", RTCIceCredentialTypePassword}, + {"oauth", RTCIceCredentialTypeOauth}, + } + + for i, testCase := range testCases { + assert.Equal(t, + NewRTCIceCredentialType(testCase.credentialTypeString), + testCase.expectedCredentialType, + "testCase: %d %v", i, testCase, + ) + } +} + +func TestRTCIceCredentialType_String(t *testing.T) { + testCases := []struct { + credentialType RTCIceCredentialType + expectedString string + }{ + {RTCIceCredentialType(Unknown), "unknown"}, + {RTCIceCredentialTypePassword, "password"}, + {RTCIceCredentialTypeOauth, "oauth"}, + } + + for i, testCase := range testCases { + assert.Equal(t, + testCase.credentialType.String(), + testCase.expectedString, + "testCase: %d %v", i, testCase, + ) + } +} diff --git a/rtcicetransportpolicy.go b/rtcicetransportpolicy.go index 68b80c97..b6c64a63 100644 --- a/rtcicetransportpolicy.go +++ b/rtcicetransportpolicy.go @@ -13,6 +13,17 @@ const ( RTCIceTransportPolicyAll ) +func NewRTCIceTransportPolicy(raw string) (unknown RTCIceTransportPolicy) { + switch raw { + case "relay": + return RTCIceTransportPolicyRelay + case "all": + return RTCIceTransportPolicyAll + default: + return unknown + } +} + func (t RTCIceTransportPolicy) String() string { switch t { case RTCIceTransportPolicyRelay: diff --git a/rtcicetransportpolicy_test.go b/rtcicetransportpolicy_test.go new file mode 100644 index 00000000..bd8f581b --- /dev/null +++ b/rtcicetransportpolicy_test.go @@ -0,0 +1,44 @@ +package webrtc + +import ( + "github.com/stretchr/testify/assert" + "testing" +) + +func TestNewRTCIceTransportPolicy(t *testing.T) { + testCases := []struct { + policyString string + expectedPolicy RTCIceTransportPolicy + }{ + {"unknown", RTCIceTransportPolicy(Unknown)}, + {"relay", RTCIceTransportPolicyRelay}, + {"all", RTCIceTransportPolicyAll}, + } + + for i, testCase := range testCases { + assert.Equal(t, + NewRTCIceTransportPolicy(testCase.policyString), + testCase.expectedPolicy, + "testCase: %d %v", i, testCase, + ) + } +} + +func TestRTCIceTransportPolicy_String(t *testing.T) { + testCases := []struct { + policy RTCIceTransportPolicy + expectedString string + }{ + {RTCIceTransportPolicy(Unknown), "unknown"}, + {RTCIceTransportPolicyRelay, "relay"}, + {RTCIceTransportPolicyAll, "all"}, + } + + for i, testCase := range testCases { + assert.Equal(t, + testCase.policy.String(), + testCase.expectedString, + "testCase: %d %v", i, testCase, + ) + } +} diff --git a/rtcpeerconnection.go b/rtcpeerconnection.go index 6e0058c4..b88c7a10 100644 --- a/rtcpeerconnection.go +++ b/rtcpeerconnection.go @@ -123,7 +123,7 @@ func (pc *RTCPeerConnection) initConfiguration(configuration RTCConfiguration) e if !x509Cert.Expires().IsZero() && now.After(x509Cert.Expires()) { return &InvalidAccessError{ErrCertificateExpired} } - pc.configuration.Certificates = append(pc.configuration.Certificates, x509Cert, ) + pc.configuration.Certificates = append(pc.configuration.Certificates, x509Cert) } } else { sk, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader) diff --git a/rtcpeerconnection_test.go b/rtcpeerconnection_test.go index dafe38fd..f8c30f62 100644 --- a/rtcpeerconnection_test.go +++ b/rtcpeerconnection_test.go @@ -4,11 +4,11 @@ import ( "crypto/ecdsa" "crypto/elliptic" "crypto/rand" - "github.com/stretchr/testify/assert" - "testing" "crypto/x509" - "time" + "github.com/stretchr/testify/assert" "math/big" + "testing" + "time" ) func TestNew(t *testing.T) { diff --git a/rtcsdptype.go b/rtcsdptype.go index be01034c..22eee8d7 100644 --- a/rtcsdptype.go +++ b/rtcsdptype.go @@ -19,6 +19,21 @@ const ( RTCSdpTypeRollback ) +func NewRTCSdpType(raw string) (unknown RTCSdpType) { + switch raw { + case "offer": + return RTCSdpTypeOffer + case "pranswer": + return RTCSdpTypePranswer + case "answer": + return RTCSdpTypeAnswer + case "rollback": + return RTCSdpTypeRollback + default: + return unknown + } +} + func (t RTCSdpType) String() string { switch t { case RTCSdpTypeOffer: diff --git a/rtcsdptype_test.go b/rtcsdptype_test.go new file mode 100644 index 00000000..066b96a0 --- /dev/null +++ b/rtcsdptype_test.go @@ -0,0 +1,48 @@ +package webrtc + +import ( + "github.com/stretchr/testify/assert" + "testing" +) + +func TestNewRTCSdpType(t *testing.T) { + testCases := []struct { + sdpTypeString string + expectedSdpType RTCSdpType + }{ + {"unknown", RTCSdpType(Unknown)}, + {"offer", RTCSdpTypeOffer}, + {"pranswer", RTCSdpTypePranswer}, + {"answer", RTCSdpTypeAnswer}, + {"rollback", RTCSdpTypeRollback}, + } + + for i, testCase := range testCases { + assert.Equal(t, + NewRTCSdpType(testCase.sdpTypeString), + testCase.expectedSdpType, + "testCase: %d %v", i, testCase, + ) + } +} + +func TestRTCSdpType_String(t *testing.T) { + testCases := []struct { + sdpType RTCSdpType + expectedString string + }{ + {RTCSdpType(Unknown), "unknown"}, + {RTCSdpTypeOffer, "offer"}, + {RTCSdpTypePranswer, "pranswer"}, + {RTCSdpTypeAnswer, "answer"}, + {RTCSdpTypeRollback, "rollback"}, + } + + for i, testCase := range testCases { + assert.Equal(t, + testCase.sdpType.String(), + testCase.expectedString, + "testCase: %d %v", i, testCase, + ) + } +} diff --git a/rtcsignalingstate.go b/rtcsignalingstate.go index 22d2b35a..b2d1d0e7 100644 --- a/rtcsignalingstate.go +++ b/rtcsignalingstate.go @@ -1,6 +1,6 @@ package webrtc -// RTCSignalingState indicates the state of the offer/answer process +// RTCSignalingState indicates the policy of the offer/answer process type RTCSignalingState int const ( diff --git a/rtcsignalingstate_test.go b/rtcsignalingstate_test.go index bf25e933..5727a810 100644 --- a/rtcsignalingstate_test.go +++ b/rtcsignalingstate_test.go @@ -20,11 +20,15 @@ func TestNewRTCSignalingState(t *testing.T) { } for i, testCase := range testCases { - assert.Equal(t, NewRTCSignalingState(testCase.stateString), testCase.expectedState, "testCase: %d %v", i, testCase) + assert.Equal(t, + NewRTCSignalingState(testCase.stateString), + testCase.expectedState, + "testCase: %d %v", i, testCase, + ) } } -func TestString(t *testing.T) { +func TestRTCSignalingState_String(t *testing.T) { testCases := []struct { state RTCSignalingState expectedString string @@ -39,6 +43,10 @@ func TestString(t *testing.T) { } for i, testCase := range testCases { - assert.Equal(t, testCase.state.String(), testCase.expectedString, "testCase: %d %v", i, testCase) + assert.Equal(t, + testCase.state.String(), + testCase.expectedString, + "testCase: %d %v", i, testCase, + ) } }