sequel_adapter_spec.rb in slosilo-0.1.2

- old
+ new
@@ -1,171 +1,60 @@
 require 'spec_helper'
-require 'sequel'
-require 'io/grab'
 
 require 'slosilo/adapters/sequel_adapter'
 
 describe Slosilo::Adapters::SequelAdapter do
-  include_context "with example key"
-
   let(:model) { double "model" }
-  before { allow(subject).to receive_messages create_model: model }
+  before { subject.stub create_model: model }
   
   describe "#get_key" do
     context "when given key does not exist" do
-      before { allow(model).to receive_messages :[] => nil }
+      before { model.stub :[] => nil }
       it "returns nil" do
-        expect(subject.get_key(:whatever)).not_to be
+        subject.get_key(:whatever).should_not be
       end
     end
-
-    context "when it exists" do
-      let(:id) { "id" }
-      before { allow(model).to receive(:[]).with(id).and_return (double "key entry", id: id, key: rsa.to_der) }
-      it "returns it" do
-        expect(subject.get_key(id)).to eq(key)
-      end
-    end
   end
   
   describe "#put_key" do
     let(:id) { "id" }
+    let(:key) { "key" }
     it "creates the key" do
-      expect(model).to receive(:create).with(hash_including(:id => id, :key => key.to_der))
-      allow(model).to receive_messages columns: [:id, :key]
+      model.should_receive(:create).with id: id, key: key
       subject.put_key id, key
     end
-
-    it "adds the fingerprint if feasible" do
-      expect(model).to receive(:create).with(hash_including(:id => id, :key => key.to_der, :fingerprint => key.fingerprint))
-      allow(model).to receive_messages columns: [:id, :key, :fingerprint]
-      subject.put_key id, key
-    end
   end
   
   let(:adapter) { subject }
   describe "#each" do
     let(:one) { double("one", id: :one, key: :onek) }
     let(:two) { double("two", id: :two, key: :twok) }
-    before { allow(model).to receive(:each).and_yield(one).and_yield(two) }
+    before { model.stub(:each).and_yield(one).and_yield(two) }
     
     it "iterates over each key" do
       results = []
-      allow(Slosilo::Key).to receive(:new) {|x|x}
       adapter.each { |id,k| results << { id => k } }
-      expect(results).to eq([ { one: :onek}, {two: :twok } ])
+      results.should == [ { one: :onek}, {two: :twok } ]
     end
   end
-
-  shared_context "database" do
+  
+  describe '#model' do
     let(:db) { Sequel.sqlite }
     before do
-      allow(subject).to receive(:create_model).and_call_original
-      Sequel::Model.cache_anonymous_models = false
+      Slosilo::encryption_key = Slosilo::Symmetric.new.random_key
+      subject.unstub :create_model
+      require 'sequel'
       Sequel::Model.db = db
-    end
-  end
-
-  shared_context "encryption key" do
-    before do
-      Slosilo.encryption_key = Slosilo::Symmetric.new.random_key
-    end
-  end
-
-  context "with old schema" do
-    include_context "encryption key"
-    include_context "database"
-
-    before do
-      db.create_table :slosilo_keystore do
-        String :id, primary_key: true
-        bytea :key, null: false
-      end
-      subject.put_key 'test', key
-    end
-
-    context "after migration" do
-      before { subject.migrate! }
-
-      it "supports look up by id" do
-        expect(subject.get_key("test")).to eq(key)
-      end
-
-      it "supports look up by fingerprint, without a warning" do
-        expect($stderr.grab do
-          expect(subject.get_by_fingerprint(key.fingerprint)).to eq([key, 'test'])
-        end).to be_empty
-      end
-    end
-
-    it "supports look up by id" do
-      expect(subject.get_key("test")).to eq(key)
-    end
-
-    it "supports look up by fingerprint, but issues a warning" do
-      expect($stderr.grab do
-        expect(subject.get_by_fingerprint(key.fingerprint)).to eq([key, 'test'])
-      end).not_to be_empty
-    end
-  end
-
-  shared_context "current schema" do
-    include_context "database"
-    before do
       Sequel.extension :migration
-      require 'slosilo/adapters/sequel_adapter/migration.rb'
-      Sequel::Migration.descendants.first.apply db, :up
+      require 'slosilo/adapters/sequel_adapter/migration'
+      Sequel::Migration::descendants.first.apply db, :up
     end
-  end
-
-  context "with current schema" do
-    include_context "encryption key"
-    include_context "current schema"
-    before do
-      subject.put_key 'test', key
-    end
-
-    it "supports look up by id" do
-      expect(subject.get_key("test")).to eq(key)
-    end
-
-    it "supports look up by fingerprint" do
-      expect(subject.get_by_fingerprint(key.fingerprint)).to eq([key, 'test'])
-    end
-  end
-
-  context "with an encryption key", :wip do
-    include_context "encryption key"
-    include_context "current schema"
-
-    it { is_expected.to be_secure }
-
-    it "saves the keys in encrypted form" do
-      subject.put_key 'test', key
-
-      expect(db[:slosilo_keystore][id: 'test'][:key]).to_not eq(key.to_der)
-      expect(subject.get_key 'test').to eq(key)
-    end
-  end
-
-  context "without an encryption key", :wip do
-    before do
-      Slosilo.encryption_key = nil
-    end
-
-    include_context "current schema"
-
-    it { is_expected.not_to be_secure }
-
-    it "refuses to store a private key" do
-      expect { subject.put_key 'test', key }.to raise_error(Slosilo::Error::InsecureKeyStorage)
-    end
-
-    it "saves the keys in plaintext form" do
-      pkey = key.public
-      subject.put_key 'test', pkey
-
-      expect(db[:slosilo_keystore][id: 'test'][:key]).to eq(pkey.to_der)
-      expect(subject.get_key 'test').to eq(pkey)
+      
+    let(:key) { 'fake key' }
+    let(:id) { 'some id' }
+    it "transforms (encrypts) the key" do
+      subject.model.create id: id, key: key
+      db[:slosilo_keystore][id: id][:key].should_not == key
+      subject.model[id].key.should == key
     end
   end
 end