ruby_smb 1.0.2 → 2.0.0

data/spec/lib/ruby_smb/smb1/tree_spec.rb

@@ -46,25 +46,34 @@ RSpec.describe RubySMB::SMB1::Tree do
   end
 
   describe '#disconnect!' do
-    it 'calls #set_header_fields' do
+    let(:disco_response) { double('Response') }
+
+    before :example do
       allow(RubySMB::SMB1::Packet::TreeDisconnectRequest).to receive(:new).and_return(disco_req)
-      allow(client).to receive(:send_recv).and_return(disco_resp.to_binary_s)
+      allow(RubySMB::SMB1::Packet::TreeDisconnectResponse).to receive(:read).and_return(disco_resp)
+      allow(client).to receive(:send_recv)
+    end
+
+    it 'calls #set_header_fields' do
       expect(tree).to receive(:set_header_fields).with(disco_req)
       tree.disconnect!
     end
 
     it 'sends a TreeDisconnectRequest with the Tree ID in the header' do
-      allow(RubySMB::SMB1::Packet::TreeDisconnectRequest).to receive(:new).and_return(disco_req)
       modified_req = disco_req
       modified_req.smb_header.tid = tree.id
-      expect(client).to receive(:send_recv).with(modified_req).and_return(disco_resp.to_binary_s)
+      expect(client).to receive(:send_recv).with(modified_req)
       tree.disconnect!
     end
 
     it 'returns the NTStatus code from the response' do
-      allow(client).to receive(:send_recv).and_return(disco_resp.to_binary_s)
       expect(tree.disconnect!).to eq disco_resp.status_code
     end
+
+    it 'raises an InvalidPacket exception if the response is not valid' do
+      allow(disco_resp).to receive(:valid?).and_return(false)
+      expect { tree.disconnect! }.to raise_error(RubySMB::Error::InvalidPacket)
+    end
   end
 
   describe '#open_file' do
@@ -239,14 +248,14 @@ RSpec.describe RubySMB::SMB1::Tree do
       end
 
       context 'when the response is not a NtCreateAndxResponse packet' do
-        it 'raise an InvalidPacket exception' do
+        it 'raises an InvalidPacket exception' do
           nt_create_andx_response.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_ECHO
           expect { tree.open_file(filename: filename) }.to raise_error(RubySMB::Error::InvalidPacket)
         end
       end
 
       context 'when the response status code is not STATUS_SUCCESS' do
-        it 'raise an UnexpectedStatusCode exception' do
+        it 'raises an UnexpectedStatusCode exception' do
           nt_create_andx_response.smb_header.nt_status = WindowsError::NTStatus::STATUS_INVALID_HANDLE.value
           expect { tree.open_file(filename: filename) }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
         end
@@ -342,6 +351,20 @@ RSpec.describe RubySMB::SMB1::Tree do
       expect(tree.list).to eq([file_info1, file_info2])
     end
 
+    context 'when the response is not a valid Trans2 FindFirst2Response' do
+      it 'raises an InvalidPacket exception' do
+        find_first2_res.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_ECHO
+        expect { tree.list }.to raise_error(RubySMB::Error::InvalidPacket)
+      end
+    end
+
+    context 'when the response status code is not STATUS_SUCCESS' do
+      it 'raises an UnexpectedStatusCode exception' do
+        find_first2_res.smb_header.nt_status = WindowsError::NTStatus::STATUS_INVALID_HANDLE.value
+        expect { tree.list }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
+      end
+    end
+
     context 'when more requests are needed to get all the information' do
       let(:find_next2_req) { RubySMB::SMB1::Packet::Trans2::FindNext2Request.new }
       let(:file_info2) do
@@ -414,6 +437,20 @@ RSpec.describe RubySMB::SMB1::Tree do
       it 'returns the expected FindFileFullDirectoryInfo structures' do
         expect(tree.list).to eq([file_info1, file_info2])
       end
+
+      context 'when the response is not a valid Trans2 FindNext2Response' do
+        it 'raises an InvalidPacket exception' do
+          find_next2_res.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_ECHO
+          expect { tree.list }.to raise_error(RubySMB::Error::InvalidPacket)
+        end
+      end
+
+      context 'when the response status code is not STATUS_SUCCESS' do
+        it 'raises an UnexpectedStatusCode exception' do
+          find_next2_res.smb_header.nt_status = WindowsError::NTStatus::STATUS_INVALID_HANDLE.value
+          expect { tree.list }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
+        end
+      end
     end
   end
 

data/spec/lib/ruby_smb/smb2/bit_field/session_flags_spec.rb

@@ -5,6 +5,7 @@ RSpec.describe RubySMB::SMB2::BitField::SessionFlags do
 
   it { is_expected.to respond_to :guest }
   it { is_expected.to respond_to :null }
+  it { is_expected.to respond_to :encrypt_data }
 
   it 'is little endian' do
     expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
@@ -25,4 +26,12 @@ RSpec.describe RubySMB::SMB2::BitField::SessionFlags do
 
     it_behaves_like 'bit field with one flag set', :null, 'v', 0x00000002
   end
+
+  describe '#encrypt_data' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.encrypt_data).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :encrypt_data, 'v', 0x00000004
+  end
 end

data/spec/lib/ruby_smb/smb2/bit_field/share_flags_spec.rb

@@ -1,6 +1,8 @@
 RSpec.describe RubySMB::SMB2::BitField::ShareFlags do
   subject(:flags) { described_class.new }
 
+  it { is_expected.to respond_to :vdo_caching }
+  it { is_expected.to respond_to :auto_caching }
   it { is_expected.to respond_to :dfs_root }
   it { is_expected.to respond_to :dfs }
   it { is_expected.to respond_to :encrypt }
@@ -11,11 +13,28 @@ RSpec.describe RubySMB::SMB2::BitField::ShareFlags do
   it { is_expected.to respond_to :namespace_caching }
   it { is_expected.to respond_to :shared_delete }
   it { is_expected.to respond_to :restrict_exclusive_opens }
+  it { is_expected.to respond_to :identity_remoting }
 
   it 'is little endian' do
     expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
   end
 
+  describe '#vdo_caching' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.vdo_caching).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :vdo_caching, 'V', 0x00000020
+  end
+
+  describe '#auto_caching' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.auto_caching).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :auto_caching, 'V', 0x00000010
+  end
+
   describe '#dfs' do
     it 'should be a 1-bit field per the SMB spec' do
       expect(flags.dfs).to be_a BinData::Bit1
@@ -96,6 +115,14 @@ RSpec.describe RubySMB::SMB2::BitField::ShareFlags do
     it_behaves_like 'bit field with one flag set', :encrypt, 'V', 0x00008000
   end
 
+  describe '#identity_remoting' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.identity_remoting).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :identity_remoting, 'V', 0x00040000
+  end
+
   describe '#set_manual_caching' do
     it 'turns off the caching bits' do
       flags.set_manual_caching

data/spec/lib/ruby_smb/smb2/file_spec.rb

@@ -43,6 +43,7 @@ RSpec.describe RubySMB::SMB2::File do
   it { is_expected.to respond_to :size }
   it { is_expected.to respond_to :size_on_disk }
   it { is_expected.to respond_to :tree }
+  it { is_expected.to respond_to :encryption_required }
 
   it 'pulls the attributes from the response packet' do
     expect(file.attributes).to eq create_response.file_attributes
@@ -52,10 +53,18 @@ RSpec.describe RubySMB::SMB2::File do
     expect(file.guid).to eq create_response.file_id
   end
 
-  it 'pulls the timestamps from the response packet' do
+  it 'pulls the last access timestamps from the response packet' do
     expect(file.last_access).to eq create_response.last_access.to_datetime
   end
 
+  it 'pulls the last change timestamps from the response packet' do
+    expect(file.last_change).to eq create_response.last_change.to_datetime
+  end
+
+  it 'pulls the last write timestamps from the response packet' do
+    expect(file.last_write).to eq create_response.last_write.to_datetime
+  end
+
   it 'pulls the size from the response packet' do
     expect(file.size).to eq create_response.end_of_file
   end
@@ -64,6 +73,10 @@ RSpec.describe RubySMB::SMB2::File do
     expect(file.size_on_disk).to eq create_response.allocation_size
   end
 
+  it 'sets the encryption_required flag to false by default' do
+    expect(file.encryption_required).to be false
+  end
+
   describe '#set_header_fields' do
     let(:request) { RubySMB::SMB2::Packet::ReadRequest.new }
     it 'calls the set_header_field method from the Tree' do
@@ -99,19 +112,59 @@ RSpec.describe RubySMB::SMB2::File do
   describe '#read' do
     context 'for a small file' do
       let(:small_read) { file.read_packet(read_length: 108) }
-      let(:small_response) { RubySMB::SMB2::Packet::ReadResponse.new(data_length: 9, buffer: 'fake data') }
+      let(:small_response) {
+        response = RubySMB::SMB2::Packet::ReadResponse.new(data_length: 9, buffer: 'fake data')
+        response.smb2_header.command = RubySMB::SMB2::Commands::READ
+        response
+      }
+
+      before :example do
+        allow(file).to receive(:read_packet)
+        allow(client).to receive(:send_recv)
+        allow(RubySMB::SMB2::Packet::ReadResponse).to receive(:read).and_return(small_response)
+      end
 
       it 'uses a single packet to read the entire file' do
         expect(file).to receive(:read_packet).with(read_length: 108, offset: 0).and_return(small_read)
-        expect(client).to receive(:send_recv).with(small_read).and_return 'fake data'
+        expect(client).to receive(:send_recv).with(small_read, encrypt: false).and_return 'fake data'
         expect(RubySMB::SMB2::Packet::ReadResponse).to receive(:read).with('fake data').and_return(small_response)
         expect(file.read).to eq 'fake data'
       end
+
+      it 'calls Client #send_recv with encryption set if required' do
+        file.encryption_required = true
+        expect(client).to receive(:send_recv).with(small_read, encrypt: true)
+        file.read
+      end
+
+      context 'when the response is not valid' do
+        it 'raise an InvalidPacket exception' do
+          small_response.smb2_header.command = RubySMB::SMB2::Commands::LOGOFF
+          expect { file.read }.to raise_error(RubySMB::Error::InvalidPacket)
+        end
+      end
+
+      context 'when the response status code is not STATUS_SUCCESS' do
+        it 'raise an UnexpectedStatusCode exception' do
+          small_response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_INVALID_HANDLE.value
+          expect { file.read }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
+        end
+      end
     end
 
     context 'for a larger file' do
       let(:big_read) { file.read_packet(read_length: 108) }
-      let(:big_response) { RubySMB::SMB2::Packet::ReadResponse.new(data_length: 9, buffer: 'fake data') }
+      let(:big_response) {
+        response = RubySMB::SMB2::Packet::ReadResponse.new(data_length: 9, buffer: 'fake data')
+        response.smb2_header.command = RubySMB::SMB2::Commands::READ
+        response
+      }
+
+      before :example do
+        allow(file).to receive(:read_packet)
+        allow(client).to receive(:send_recv)
+        allow(RubySMB::SMB2::Packet::ReadResponse).to receive(:read).and_return(big_response)
+      end
 
       it 'uses a multiple packet to read the file in chunks' do
         expect(file).to receive(:read_packet).once.with(read_length: described_class::MAX_PACKET_SIZE, offset: 0).and_return(big_read)
@@ -120,6 +173,32 @@ RSpec.describe RubySMB::SMB2::File do
         expect(RubySMB::SMB2::Packet::ReadResponse).to receive(:read).twice.with('fake data').and_return(big_response)
         file.read(bytes: (described_class::MAX_PACKET_SIZE * 2))
       end
+
+      it 'calls Client #send_recv with encryption set if required' do
+        read_request = double('Read Request')
+        allow(file).to receive(:read_packet).and_return(read_request)
+        file.encryption_required = true
+        expect(client).to receive(:send_recv).twice.with(read_request, encrypt: true)
+        file.read(bytes: (described_class::MAX_PACKET_SIZE * 2))
+      end
+
+      context 'when the second response is not valid' do
+        it 'raise an InvalidPacket exception' do
+          allow(file).to receive(:read_packet).with(read_length: described_class::MAX_PACKET_SIZE, offset: described_class::MAX_PACKET_SIZE) do
+            big_response.smb2_header.command = RubySMB::SMB2::Commands::LOGOFF
+          end
+          expect { file.read(bytes: (described_class::MAX_PACKET_SIZE * 2)) }.to raise_error(RubySMB::Error::InvalidPacket)
+        end
+      end
+
+      context 'when the second response status code is not STATUS_SUCCESS' do
+        it 'raise an UnexpectedStatusCode exception' do
+          allow(file).to receive(:read_packet).with(read_length: described_class::MAX_PACKET_SIZE, offset: described_class::MAX_PACKET_SIZE) do
+            big_response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_INVALID_HANDLE.value
+          end
+          expect { file.read(bytes: (described_class::MAX_PACKET_SIZE * 2)) }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
+        end
+      end
     end
   end
 
@@ -152,6 +231,14 @@ RSpec.describe RubySMB::SMB2::File do
         expect(client).to receive(:send_recv).once.and_return(write_response.to_binary_s)
         file.write(data: 'test')
       end
+
+      it 'calls Client #send_recv with encryption set if required' do
+        write_request = double('Write Request')
+        allow(file).to receive(:write_packet).and_return(write_request)
+        file.encryption_required = true
+        expect(client).to receive(:send_recv).once.with(write_request, encrypt: true).and_return(write_response.to_binary_s)
+        file.write(data: 'test')
+      end
     end
 
     context 'for a large write' do
@@ -159,6 +246,21 @@ RSpec.describe RubySMB::SMB2::File do
         expect(client).to receive(:send_recv).twice.and_return(write_response.to_binary_s)
         file.write(data: SecureRandom.random_bytes(described_class::MAX_PACKET_SIZE + 1))
       end
+
+      it 'calls Client #send_recv with encryption set if required' do
+        write_request = double('Write Request')
+        allow(file).to receive(:write_packet).and_return(write_request)
+        file.encryption_required = true
+        expect(client).to receive(:send_recv).twice.with(write_request, encrypt: true).and_return(write_response.to_binary_s)
+        file.write(data: SecureRandom.random_bytes(described_class::MAX_PACKET_SIZE + 1))
+      end
+    end
+
+    it 'raises an InvalidPacket exception if the response is not valid' do
+      allow(client).to receive(:send_recv)
+      allow(RubySMB::SMB2::Packet::WriteResponse).to receive(:read).and_return(write_response)
+      allow(write_response).to receive(:valid?).and_return(false)
+      expect { file.write(data: 'test') }.to raise_error(RubySMB::Error::InvalidPacket)
     end
   end
 
@@ -189,10 +291,26 @@ RSpec.describe RubySMB::SMB2::File do
 
       it 'uses a single packet to delete the entire file' do
         expect(file).to receive(:delete_packet).and_return(small_delete)
-        expect(client).to receive(:send_recv).with(small_delete).and_return 'raw_response'
+        expect(client).to receive(:send_recv).with(small_delete, encrypt: false).and_return 'raw_response'
         expect(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).with('raw_response').and_return(small_response)
         expect(file.delete).to eq WindowsError::NTStatus::STATUS_SUCCESS
       end
+
+      it 'raises an InvalidPacket exception if the response is not valid' do
+        allow(file).to receive(:delete_packet)
+        allow(client).to receive(:send_recv)
+        allow(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).and_return(small_response)
+        allow(small_response).to receive(:valid?).and_return(false)
+        expect { file.delete }.to raise_error(RubySMB::Error::InvalidPacket)
+      end
+
+      it 'calls Client #send_recv with encryption set if required' do
+        allow(file).to receive(:delete_packet)
+        allow(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).and_return(small_response)
+        file.encryption_required = true
+        expect(client).to receive(:send_recv).with(small_delete, encrypt: true)
+        file.delete
+      end
     end
   end
 
@@ -224,10 +342,209 @@ RSpec.describe RubySMB::SMB2::File do
 
       it 'uses a single packet to rename the entire file' do
         expect(file).to receive(:rename_packet).and_return(small_rename)
-        expect(client).to receive(:send_recv).with(small_rename).and_return 'raw_response'
+        expect(client).to receive(:send_recv).with(small_rename, encrypt: false).and_return 'raw_response'
         expect(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).with('raw_response').and_return(small_response)
         expect(file.rename('new_file.txt')).to eq WindowsError::NTStatus::STATUS_SUCCESS
       end
+
+      it 'calls Client #send_recv with encryption set if required' do
+        allow(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).and_return(small_response)
+        file.encryption_required = true
+        expect(client).to receive(:send_recv).with(small_rename, encrypt: true)
+        file.rename('new_file.txt')
+      end
+
+      it 'raises an InvalidPacket exception if the response is not valid' do
+        allow(client).to receive(:send_recv)
+        allow(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).and_return(small_response)
+        allow(small_response).to receive(:valid?).and_return(false)
+        expect { file.rename('new_file.txt') }.to raise_error(RubySMB::Error::InvalidPacket)
+      end
+    end
+  end
+
+  describe '#close' do
+    let(:request)  { double('CloseRequest') }
+    let(:response) { double('CloseResponse') }
+    let(:raw_response) { double('Raw response') }
+
+    before :example do
+      allow(RubySMB::SMB2::Packet::CloseRequest).to receive(:new).and_return(request)
+      allow(file).to receive(:set_header_fields).and_return(request)
+      allow(client).to receive(:send_recv).and_return(raw_response)
+      allow(RubySMB::SMB2::Packet::CloseResponse).to receive(:read).and_return(response)
+      allow(response).to receive(:valid?).and_return(true)
+      allow(response).to receive(:status_code).and_return(WindowsError::NTStatus::STATUS_SUCCESS)
+    end
+
+    it 'creates a new SMB2 CloseRequest packet' do
+      expect(RubySMB::SMB2::Packet::CloseRequest).to receive(:new)
+      file.close
+    end
+
+    it 'calls Tree #set_header_fields to set SetFileInformationRequest headers' do
+      expect(file).to receive(:set_header_fields).with(request)
+      file.close
+    end
+
+    it 'calls Client #send_recv with the expected request' do
+      expect(client).to receive(:send_recv).with(request, encrypt: false)
+      file.close
+    end
+
+    it 'calls Client #send_recv with encryption set if required' do
+      file.encryption_required = true
+      expect(client).to receive(:send_recv).with(request, encrypt: true)
+      file.close
+    end
+
+    it 'parses the response as a SMB2 CloseResponse packet' do
+      expect(RubySMB::SMB2::Packet::CloseResponse).to receive(:read).with(raw_response)
+      file.close
+    end
+
+    it 'raises an InvalidPacket exception if the response is not valid' do
+      allow(response).to receive(:valid?).and_return(false)
+      smb2_header = double('SMB2 Header')
+      allow(response).to receive(:smb2_header).and_return(smb2_header)
+      allow(smb2_header).to receive_messages(:protocol => nil, :command => nil)
+      expect { file.close }.to raise_error(RubySMB::Error::InvalidPacket)
+    end
+
+    it 'raises an UnexpectedStatusCode exception if the response status code is not STATUS_SUCCESS' do
+      allow(response).to receive(:status_code).and_return(WindowsError::NTStatus::STATUS_OBJECT_NAME_NOT_FOUND)
+      expect { file.close }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
+    end
+
+    it 'returns the response status code' do
+      expect(file.close).to eq WindowsError::NTStatus::STATUS_SUCCESS
+    end
+  end
+
+  describe '#send_recv_read' do
+    let(:read_data) { 'read data' }
+    let(:raw_response) { double('fake raw response data') }
+    let(:read_response) {
+      res = RubySMB::SMB2::Packet::ReadResponse.new
+      res.data_length = read_data.size
+      res.buffer = read_data
+      res
+    }
+
+    before :example do
+      allow(client).to receive(:send_recv).and_return(raw_response)
+      allow(RubySMB::SMB2::Packet::ReadResponse).to receive(:read).with(raw_response).and_return(read_response)
+    end
+
+    context 'when the number of bytes to read is not provided' do
+      it 'reads 0 bytes by default' do
+        expect(file).to receive(:read_packet).with(read_length: 0, offset: 0).once.and_call_original
+        file.send_recv_read
+      end
+    end
+
+    it 'only reads the number of bytes provided as argument' do
+      bytes = 5
+      expect(file).to receive(:read_packet).with(read_length: bytes, offset: 0).once.and_call_original
+      file.send_recv_read(read_length: bytes)
+    end
+
+    it 'reads from the offset provided as argument' do
+      offset = 3
+      expect(file).to receive(:read_packet).with(read_length: 0, offset: offset).once.and_call_original
+      file.send_recv_read(offset: offset)
+    end
+
+    it 'calls Client #send_recv with the expected request' do
+      request = double('Request')
+      allow(file).to receive(:read_packet).and_return(request)
+      expect(client).to receive(:send_recv).with(request, encrypt: false)
+      file.send_recv_read
+    end
+
+    it 'calls Client #send_recv with encryption set if required' do
+      request = double('Request')
+      allow(file).to receive(:read_packet).and_return(request)
+      file.encryption_required = true
+      expect(client).to receive(:send_recv).with(request, encrypt: true)
+      file.send_recv_read
+    end
+
+    it 'parses the response as a SMB2 ReadResponse packet' do
+      expect(RubySMB::SMB2::Packet::ReadResponse).to receive(:read).with(raw_response)
+      file.send_recv_read
+    end
+
+    it 'raises an InvalidPacket exception if the response is not valid' do
+      allow(read_response).to receive(:valid?).and_return(false)
+      expect { file.send_recv_read }.to raise_error(RubySMB::Error::InvalidPacket)
+    end
+
+    it 'raises an UnexpectedStatusCode exception if the response status code is not STATUS_SUCCESS' do
+      allow(read_response).to receive(:status_code).and_return(WindowsError::NTStatus::STATUS_OBJECT_NAME_NOT_FOUND)
+      expect { file.send_recv_read }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
+    end
+
+    it 'returns the expected string' do
+      expect(file.send_recv_read).to eq(read_data)
+    end
+  end
+
+  describe '#send_recv_write' do
+    let(:write_data) { 'write data' }
+    let(:request) { double('Request') }
+    let(:raw_response) { double('fake raw response data') }
+    let(:write_response) {
+      res = RubySMB::SMB2::Packet::WriteResponse.new
+      res.write_count = write_data.size
+      res
+    }
+
+    before :example do
+      allow(file).to receive(:write_packet).and_return(request)
+      allow(client).to receive(:send_recv).and_return(raw_response, encrypt: false)
+      allow(RubySMB::SMB2::Packet::WriteResponse).to receive(:read).with(raw_response).and_return(write_response)
+    end
+
+    it 'reads 0 bytes from offset 0 by default' do
+      expect(file).to receive(:write_packet).with(data: '', offset: 0).once.and_call_original
+      file.send_recv_write
+    end
+
+    it 'writes the data provided as argument' do
+      expect(file).to receive(:write_packet).with(data: write_data, offset: 0).once.and_call_original
+      file.send_recv_write(data: write_data)
+    end
+
+    it 'reads from the offset provided as argument' do
+      offset = 3
+      expect(file).to receive(:write_packet).with(data: '', offset: offset).once.and_call_original
+      file.send_recv_write(offset: offset)
+    end
+
+    it 'calls Client #send_recv with the expected request' do
+      expect(client).to receive(:send_recv).with(request, encrypt: false)
+      file.send_recv_write
+    end
+
+    it 'calls Client #send_recv with encryption set if required' do
+      file.encryption_required = true
+      expect(client).to receive(:send_recv).with(request, encrypt: true)
+      file.send_recv_write
+    end
+
+    it 'parses the response as a SMB1 WriteResponse packet' do
+      expect(RubySMB::SMB2::Packet::WriteResponse).to receive(:read).with(raw_response)
+      file.send_recv_write
+    end
+
+    it 'raises an InvalidPacket exception if the response is not valid' do
+      allow(write_response).to receive(:valid?).and_return(false)
+      expect { file.send_recv_write }.to raise_error(RubySMB::Error::InvalidPacket)
+    end
+
+    it 'returns the expected response #write_count value' do
+      expect(file.send_recv_write).to eq(write_data.size)
     end
   end
 end