Which behavior of this method I should test? - ruby-on-rails

Question

I would like to test save method:
class Note
def initialize(password)
#password = password
end
def save
encryption = Note::Encryption.new(#password)
encrypted = encryption.encrypt(serialized)
storage = Note::Storage.new
storage.write(encrypted)
end
private
def serialized
{some_data: true}
end
# .....
end
Method just delegates work to the other classes mainly, and that's the only responsibility. My first bet to testing it is just checking:
describe '#save' do
let(:encryption){ '12345' }
it 'calls encryption' do
expect_any_instance_of(Note::Encryption).to receive(:encrypt)
subject.save
end
it 'saves the file with data' do
expect_any_instance_of(Note::Storage).to receive(:write)
subject.save
end
end
I've problem with this approach as I'm little bit afraid that these tests don't test too much... Moreover test now is high coupled with the implementation not behavior. Do anyone know how to approach to this kind of methods. Worth to mention that this class would be at the top of system as wraps some resource.

Answer 1

I would test a bit more, because I would like to be sure about the arguments passed to that methods:
class Note
def initialize(password)
#password = password
end
def save
encrypted = Note::Encryption.new(#password).encrypt(serialized)
Note::Storage.new.write(encrypted)
end
private
def serialized
{some_data: true}
end
end
# the test
describe '#save' do
let(:password) { 'secret password' }
let(:encryted) { 'encrytped string' }
let(:storage) { double(:write => true) }
let(:note_encryption) { double(:encrypt => encrypted) }
subject(:note) { Note.new(password) }
before do
allow(Note::Encryption).to receive(:new).with(password).and_return(note_encryption)
Note::Storage.stub(:new => storage)
end
it 'encrypted the password' do
note.save
expect(Note::Encryption).to have_received(:new).with(password)
expect(note_encryption).to have_received(:encrypt).with(serialized) # mock serialized?
end
it 'stores the encryted string' do
note.save
expect(storage).to have_received(:write).with(encrypted)
end
end

Answer 2

If you look at the method, there are a few discrete things that it is doing:
def save
encryption = Note::Encryption.new(#password)
encrypted = encryption.encrypt(serialized) # first action
storage = Note::Storage.new
storage.write(encrypted) # second action
end
Those are the things you should test, along with validations - what happens if #password is an empty string?
Tests could look something like this:
let(:password) { 'my_pass' }
let(:note) { Note.new(password) }
let(:result) { note.save }
describe 'save' do
describe 'with a blank password' do
let(:password) { '' }
it 'fails' do
# assert_raises...
end
end
it 'encrypts the password' do
refute_same password, result #of course, this depends on what Storage.write returns...
end
it 'saves the password' do
# assert that the password is saved
end
end
Also, if I can suggest a refactor -
class Note
def initialize(password)
#password = password
end
def save
encrypted = build_encrypted_object
storage.write(encrypted)
end
private
def build_encrypted_object
encryption.encrypt(serialized)
end
def serialized
{some_data: true}
end
def encryption
Note::Encryption.new(#password)
end
def storage
Note::Storage.new
end
# .....
end