update tests

Author: ckoegel

spec/smoke/toll_free_verification_api_spec.rb

@@ -29,6 +29,13 @@
     end
   end
 
+    # Delete a Toll-Free Verification Submission
+  describe 'delete_verification_request' do
+    it 'deletes a toll free verification submission' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
   # List Toll-Free Use Cases
   describe 'list_toll_free_use_cases test' do
     it 'lists toll free use cases' do

spec/unit/api/toll_free_verification_api_spec.rb

@@ -136,6 +136,14 @@
     end
   end
 
+  # Delete a Toll-Free Verification Submission
+  describe 'delete_verification_request' do
+    it 'deletes a toll free verification submission' do
+      _data, status_code = @tfv_api_instance.delete_verification_request_with_http_info(BW_ACCOUNT_ID, tf_phone_number)
+      expect(status_code).to eq(204)
+    end
+  end
+
   # List Toll-Free Use Cases
   describe 'list_toll_free_use_cases test' do
     it 'lists toll free use cases' do

spec/unit/client/api_client_spec.rb

@@ -268,7 +268,7 @@
       expect(api_client_default.convert_to_type({ id: 1 }, 'Object')).to eq({ id: 1 })
       expect(api_client_default.convert_to_type([[12, 34], [56]], 'Array<Array<Integer>>')).to eq([[12, 34], [56]])
       expect(api_client_default.convert_to_type({ "id": 'test' }, 'Hash<String, String>')).to eq({ id: 'test' })
-      expect(api_client_default.convert_to_type({ set_or_expired: true }, 'DeferredResult')).to be_instance_of(Bandwidth::DeferredResult)
+      expect(api_client_default.convert_to_type({ valid: true }, 'VerifyCodeResponse')).to be_instance_of(Bandwidth::VerifyCodeResponse)
     end
   end
 
@@ -353,10 +353,10 @@
     end
 
     it 'returns hash when object can be converted to hash' do
-      model = Bandwidth::DeferredResult.new({
-        set_or_expired: true
+      model = Bandwidth::VerifyCodeResponse.new({
+        valid: true
       })
-      expected = { setOrExpired: true }
+      expected = { valid: true }
       expect(api_client_default.object_to_hash(model)).to eq(expected)
     end
   end

spec/unit/models/deferred_result_spec.rb

@@ -0,0 +1,78 @@
+# Unit tests for Bandwidth::TfvError
+describe Bandwidth::TfvError do
+  let(:tfv_error_default) { Bandwidth::TfvError.new }
+  let(:tfv_error_values) { Bandwidth::TfvError.new({
+    type: 'type',
+    description: 'description',
+    errors: { key: 'value' }
+  }) }
+
+  describe '#initialize' do
+    it 'causes an ArgumentError by passing an Array to the initialize method' do
+      expect {
+        Bandwidth::TfvError.new([])
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'causes an ArgumentError by passing an invalid attribute to the initialize method' do
+      expect {
+        Bandwidth::TfvError.new({ invalid: true })
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#acceptable_attributes' do
+    it 'expects acceptable JSON attributes to be those in the attribute map' do
+      expect(Bandwidth::TfvError.acceptable_attributes).to eq(Bandwidth::TfvError.attribute_map.values)
+    end
+  end
+
+  describe 'enum validation' do
+    it 'works' do
+      
+    end
+  end
+
+  describe '#build_from_hash' do
+    it 'validates instance of TfvError created by the build_from_hash method' do
+      tfv_error_from_hash = Bandwidth::TfvError.build_from_hash({
+        type: 'type',
+        description: 'description',
+        errors: { key: 'value' }
+      })
+      expect(tfv_error_from_hash).to be_instance_of(Bandwidth::TfvError)
+      expect(tfv_error_from_hash.type).to eq('type')
+      expect(tfv_error_from_hash.description).to eq('description')
+      expect(tfv_error_from_hash.errors).to eq({ key: 'value' })
+    end
+  end
+
+  describe '#hash' do
+    it 'returns a hash code according to attributes' do
+      expect(tfv_error_default.hash).to be_instance_of(Integer)
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns a string representation of the object' do
+      expect(tfv_error_values.to_s).to eq('{:type=>"type", :description=>"description", :errors=>{:key=>"value"}}')
+    end
+  end
+
+  describe '#eq? #==' do
+    it 'returns true/false when comparing objects' do
+      expect(tfv_error_default.eql?(Bandwidth::TfvError.new)).to be true
+      expect(tfv_error_default.eql?(tfv_error_values)).to be false
+    end
+  end
+
+  describe '#to_body #to_hash' do
+    it 'returns a hash representation of the object' do
+      expect(tfv_error_values.to_body).to eq({
+        type: 'type',
+        description: 'description',
+        errors: { key: 'value' }
+      })
+    end
+  end
+end

spec/unit/models/tfv_error_spec.rb

@@ -0,0 +1,70 @@
+# Unit tests for Bandwidth::VerifyCodeResponse
+describe Bandwidth::VerifyCodeResponse do
+  let(:verify_code_response_default) { Bandwidth::VerifyCodeResponse.new }
+  let(:verify_code_response_values) { Bandwidth::VerifyCodeResponse.new({
+    valid: true
+  }) }
+
+  describe '#initialize' do
+    it 'causes an ArgumentError by passing an Array to the initialize method' do
+      expect {
+        Bandwidth::VerifyCodeResponse.new([])
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'causes an ArgumentError by passing an invalid attribute to the initialize method' do
+      expect {
+        Bandwidth::VerifyCodeResponse.new({ invalid: true })
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#acceptable_attributes' do
+    it 'expects acceptable JSON attributes to be those in the attribute map' do
+      expect(Bandwidth::VerifyCodeResponse.acceptable_attributes).to eq(Bandwidth::VerifyCodeResponse.attribute_map.values)
+    end
+  end
+
+  describe '#openapi_nullable' do
+    it 'expects nullable attributes to be an empty set' do
+      expect(Bandwidth::VerifyCodeResponse.openapi_nullable).to eq(Set.new([]))
+    end
+  end
+
+  describe '#build_from_hash' do
+    it 'validates instance of VerifyCodeResponse created by the build_from_hash method' do
+      verify_code_response_from_hash = Bandwidth::VerifyCodeResponse.build_from_hash({
+        valid: true
+      })
+      expect(verify_code_response_from_hash).to be_instance_of(Bandwidth::VerifyCodeResponse)
+      expect(verify_code_response_from_hash.valid).to be true
+    end
+  end
+  
+  describe '#hash' do
+    it 'returns a hash code according to attributes' do
+      expect(verify_code_response_default.hash).to be_instance_of(Integer)
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns a string representation of the object' do
+      expect(verify_code_response_values.to_s).to eq('{:valid=>true}')
+    end
+  end
+
+  describe '#eq? #==' do
+    it 'returns true/false when comparing objects' do
+      expect(verify_code_response_default.eql?(Bandwidth::VerifyCodeResponse.new)).to be true
+      expect(verify_code_response_default.eql?(verify_code_response_values)).to be false
+    end
+  end
+
+  describe '#to_body #to_hash' do
+    it 'returns a hash representation of the object' do
+      expect(verify_code_response_values.to_body).to eq({
+        valid: true
+      })
+    end
+  end
+end