keystorage 0.5.1 → 0.5.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad8f4fbc6eb42851fd6be0c507430a1715894da4
-  data.tar.gz: 31cd005dbc8e0c2c813d91e6d23b730911115c43
+  metadata.gz: 5772937588dc3df5bec1a71d4decdb377c44cc5d
+  data.tar.gz: cea3aa650a0c1e8ff6737b5c89a24efd19c3d926
 SHA512:
-  metadata.gz: 2af20459da3de9df711bd72f021ff74c011fed2a749903b85f2a35ff501a17b78a0e6f3ce0a2e8ad86ae42815bbc757843e7448cef06158f9de85256920eeb12
-  data.tar.gz: f46d937aa796ba6cf144e9127918d66c62b217fb7ab338d049e08fa0830c55a3d40bf9862d29fa53215b4631281308cf8074e2ad6a758e347c92d7236ecdb24e
+  metadata.gz: 3c94373cfc511b914ed78315639242b650bd79158d2f0c7dff814f8490ad1e555b7c280f30fd9e5175d9c8336be2d9a8343fe07a91c6bc16344bdaaa2f58bcfe
+  data.tar.gz: bf1b0665cd890f17fb6c3c0294224861038f942ee1a5b60f585c1fd93d976fe2d394b07b22346ce79ce15437f29d9197313f0f81fc16ab6c7e119892872dd1d3

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.2.0
+addons:
+  code_climate:
+    repo_token: 7e1de01d60bd2dd9dac1bf49ab3e62b631f1299dde4c0f4595f277ae01c1e9f4

data/Gemfile

@@ -1,9 +1,5 @@
 source "http://rubygems.org"
 gemspec
 
-# Add dependencies required to use your gem here.
-# Example:
-#   gem "activesupport", ">= 2.3.5"
-
-# Add dependencies to develop your gem here.
-# Include everything needed to run rake, tests, features, etc.
+gem "simplecov", :require=>false, group: :test
+gem "codeclimate-test-reporter", group: :test

data/README.md

@@ -1,6 +1,11 @@
 keystorage
 ----------
 
+[![Gem Version](https://badge.fury.io/rb/keystorage.svg)](http://badge.fury.io/rb/keystorage)
+[![Build Status](https://travis-ci.org/tumf/keystorage.svg?branch=master)](https://travis-ci.org/tumf/keystorage)
+[![Code Climate](https://codeclimate.com/github/tumf/keystorage/badges/gpa.svg)](https://codeclimate.com/github/tumf/keystorage)
+[![Test Coverage](https://codeclimate.com/github/tumf/keystorage/badges/coverage.svg)](https://codeclimate.com/github/tumf/keystorage)
+
 Simple password storage.
 
 ## Install
@@ -12,12 +17,14 @@ Simple password storage.
 
     -> % keystorage
     Commands:
+      keystorage exec            # execute child process with set envvars
       keystorage get             # Get a encrypted value of the key of the group
       keystorage groups          # List groups
       keystorage help [COMMAND]  # Describe available commands or one specific command
       keystorage keys            # List keys of the group
       keystorage password        # Update storage secret
       keystorage set             # Set a value of the key of the group
+      keystorage version         # show version info
 
     Options:
       -v, [--verbose], [--no-verbose]

data/Rakefile

@@ -4,4 +4,4 @@ Rake::VersionTask.new
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :test
+task :default => [:spec]

data/VERSION

@@ -1 +1 @@
-0.5.1
+0.5.7

data/bin/keystorage

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
 $:.unshift(File.join(File.dirname(__FILE__),'..','lib'))
+require 'bundler/setup'
 require 'keystorage/cli'
 Keystorage::CLI.start(ARGV)

data/keystorage.gemspec

@@ -27,8 +27,9 @@ Gem::Specification.new do |s|
   s.summary = "Simple password storage"
 
   s.add_dependency('thor')
-  
+  s.add_dependency('version')
+
   s.add_development_dependency('rake')
   s.add_development_dependency('rspec')
-  s.add_development_dependency('version')
+  s.add_development_dependency('fakefs')
 end

data/lib/keystorage.rb

@@ -15,62 +15,6 @@ module Keystorage
   class NoSecret < StandardError; end
   class FormatNotSupport < StandardError; end
 
-  def sign message,secret=secret
-    raise NoSecret.new("set env KEYSTORAGE_SECRET") unless secret
-    OpenSSL::HMAC.hexdigest('sha512',secret, message)
-  end
-
-  def token
-    SecureRandom.urlsafe_base64(nil, false)
-  end
-
-  def root
-    raise NoRootGroup unless file.has_key?("@")
-    file["@"] || {}
-  end
-
-  def root! secret=secret,data=file
-    data["@"] = {}
-    data["@"]["token"] = token
-    data["@"]["sig"] = sign(data["@"]["token"],secret)
-    data
-  end
-
-  # file validation
-  def valid?
-    sign(root["token"]) == root["sig"]
-  rescue NoRootGroup
-    write root!
-  end
-
-  def encode(str,secret=secret)
-    enc = OpenSSL::Cipher::Cipher.new('aes256')
-    enc.encrypt.pkcs5_keyivgen(secret)
-    ((enc.update(str) + enc.final).unpack("H*")).first.to_s
-  end
-
-  def decode(str,secret=secret)
-    dec = OpenSSL::Cipher::Cipher.new('aes256')
-    dec.decrypt.pkcs5_keyivgen(secret)
-    (dec.update(Array.new([str]).pack("H*")) + dec.final)
-  end
-
-  def path
-    options[:file] || ENV['KEYSTORAGE_FILE'] || DEFAULT_FILE
-  end
-
-  def file
-    YAML.load(File.new(path)) || {}
-  end
-
-  def write data
-    File.open(path,'w',0600) { |f| YAML.dump(data,f) }
-  end
-
-  def secret
-    options[:secret] || ENV['KEYSTORAGE_SECRET'] || DEFAULT_SECRET
-  end
-
   def render out,format =:text
     case format
     when :text then

data/lib/keystorage/cli.rb

@@ -3,6 +3,7 @@ require 'keystorage'
 require 'keystorage/manager'
 require 'thor'
 require 'optparse'
+require 'version'
 
 module Keystorage
   class CLI < Thor
@@ -12,22 +13,22 @@ module Keystorage
       def start(given_args = ARGV, config = {})
         # parse global options: Thor is not support global-options.
         # Like: command global-options subcommand options
-        global_options = []
+        new_global_options = []
         OptionParser.new do |opt|
           @global_options.each { |name,config|
             case config[:type]
             when :boolean then
-              opt.on(config[:aliases],"--#{name.to_s}") { |v| global_options << "--#{name.to_s}"}
-              opt.on(config[:aliases],"--no-#{name.to_s}") { |v| global_options << "--no-#{name.to_s}"}
+              opt.on(config[:aliases],"--#{name.to_s}") { |v| new_global_options << "--#{name.to_s}"}
             when :string then
-              opt.on(config[:aliases],"--#{name.to_s}=VALUE") { |v| global_options << "--#{name.to_s}=#{v}"}
+              opt.on(config[:aliases],"--#{name.to_s}=VALUE") { |v| new_global_options << "--#{name.to_s}=#{v}"}
             end
           }
           opt.parse!(given_args)
         end
-        given_args+=global_options
+        given_args+=new_global_options
         super(given_args,config)
       end
+      attr_reader :global_options
 
       def global_option *params
         @global_options ||= {}
@@ -68,5 +69,16 @@ module Keystorage
       Manager.new(options).password(new_secret)
     end
 
+    desc "exec","execute child process with set envvars"
+    def exec *command
+      #@todo: ask if new_secret == nil
+      Manager.new(options).exec(command)
+    end
+
+    desc "version","show version info"
+    def version
+      puts Version.current
+    end
+
   end
 end

data/lib/keystorage/manager.rb

@@ -56,5 +56,79 @@ module Keystorage
       retry
     end
 
+    def exec *cmd
+      raise SecretMissMatch unless valid?
+      system(envs.collect{ |k,v| "#{k}='#{v}'" }.join(' ') + " " + cmd.join(' '))
+    end
+
+    private
+
+    def envs
+      result = {}
+      groups.each { |g|
+        keys(g).each { |k|
+          result["#{g}_#{k}"] = get(g,k)
+        }
+      }
+      result
+    end
+
+    def sign message,_secret=secret
+      raise NoSecret.new("set env KEYSTORAGE_SECRET") unless _secret
+      OpenSSL::HMAC.hexdigest('sha512',_secret, message)
+    end
+
+    def token
+      SecureRandom.urlsafe_base64(nil, false)
+    end
+
+    def root
+      raise NoRootGroup unless file.has_key?("@")
+      file["@"] || {}
+    end
+
+    def root! _secret=secret,data=file
+      data["@"] = {}
+      data["@"]["token"] = token
+      data["@"]["sig"] = sign(data["@"]["token"],_secret)
+      data
+    end
+
+    # file validation
+    def valid?
+      sign(root["token"]) == root["sig"]
+    rescue NoRootGroup
+      write root! and true
+    end
+
+    def encode(str,_secret=secret)
+      enc = OpenSSL::Cipher::Cipher.new('aes256')
+      enc.encrypt.pkcs5_keyivgen(_secret)
+      ((enc.update(str) + enc.final).unpack("H*")).first.to_s
+    end
+
+    def decode(str,_secret=secret)
+      dec = OpenSSL::Cipher::Cipher.new('aes256')
+      dec.decrypt.pkcs5_keyivgen(_secret)
+      (dec.update(Array.new([str]).pack("H*")) + dec.final)
+    end
+
+    def path
+      options[:file] || ENV['KEYSTORAGE_FILE'] || DEFAULT_FILE
+    end
+
+    def file
+      YAML.load(File.new(path)) || {}
+    end
+
+    def write data
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path,'w',0600) { |f| YAML.dump(data,f) }
+    end
+
+    def secret
+      options[:secret] || ENV['KEYSTORAGE_SECRET'] || DEFAULT_SECRET
+    end
+
   end
 end

data/spec/keystorage/cli_spec.rb

@@ -1,7 +1,120 @@
+# coding: utf-8
 require 'keystorage/cli'
+
 describe Keystorage::CLI do
-  subject { Keystorage::CLI::new(['-f','test.yml']).options[:file] }
-  it {
-    is_expected.to be ''
-  }
+  subject { Keystorage::CLI.start(argv) }
+
+  describe ".start" do
+    context "unknown global-options are specified" do
+      let(:argv) { ['--aaa=myfile','groups'] }
+      it "puts options back of subcommand" do
+        expect { subject }.to raise_error(OptionParser::InvalidOption)
+      end
+    end
+
+    context "string-type global-options are specified" do
+      let(:argv) { ['-f','myfile','groups'] }
+      it "puts options back of subcommand" do
+        expect(Thor).to receive(:start).with(['groups','--file=myfile'],{}).once
+        subject
+      end
+    end
+
+    context "boolean-type `-v` global-options are specified" do
+      let(:argv) { ['-v','groups'] }
+      it "puts options back of subcommand" do
+        expect(Thor).to receive(:start).with(['groups','--verbose'],{}).once
+        subject
+      end
+    end
+    context "boolean-type `--no-verbose` global-options are specified" do
+      let(:argv) { ['--no-verbose','groups'] }
+      it "puts options back of subcommand" do
+        expect { subject }.to raise_error(OptionParser::InvalidOption)
+      end
+    end
+  end
+
+  describe ".global_option" do
+    it "adds to @global_options and call `class_option`" do
+      expect(Keystorage::CLI).to receive(:class_option)
+                                  .with(:test, :aliases =>"-t", :type => :boolean).once
+      Keystorage::CLI.global_option(:test, :aliases =>"-t", :type => :boolean)
+      expect(Keystorage::CLI.global_options.has_key?(:test)).to be true
+    end
+  end
+
+  describe "#groups" do
+    let(:argv) { ['groups'] }
+    it "puts list of groups" do
+      allow(Keystorage::Manager).to receive_message_chain('new.groups')
+                                     .and_return( ["group1","group2","group3"] )
+      expect(STDOUT).to receive(:puts).with("group1\ngroup2\ngroup3").once
+      subject
+    end
+  end
+
+  describe "#keys" do
+    let(:argv) { ['keys','group1'] }
+    it "puts keys in the group" do
+      allow(Keystorage::Manager).to receive_message_chain('new.keys')
+                                     .and_return( ["key1","key2","key3"] )
+
+      expect(STDOUT).to receive(:puts).with("key1\nkey2\nkey3").once
+      subject
+    end
+  end
+
+  describe "#get" do
+    let(:argv) { ['get','group1','key1'] }
+    it "puts value of the key in the group" do
+      allow(Keystorage::Manager).to receive_message_chain('new.get')
+                                     .and_return( ["value"] )
+
+      expect(STDOUT).to receive(:puts).with("value").once
+      subject
+    end
+  end
+
+
+  describe "#set" do
+    let(:argv) { ['set','group1','key1','vaule'] }
+    it "sets value of the key in the group" do
+      allow(Keystorage::Manager).to receive_message_chain('new.set')
+                                     .and_return("value")
+
+      expect(STDOUT).to receive(:puts).with("value").once
+      subject
+    end
+  end
+
+  describe "#password" do
+    let(:argv) { ['password','p@ssw0rd'] }
+    it "updates secret of all keys in the file" do
+      expect(Keystorage::Manager).to receive_message_chain('new.password')
+                                      .with('p@ssw0rd')
+      subject
+    end
+  end
+
+  describe "#exec" do
+    let(:argv) { ['exec','mycommand','arg1','arg2'] }
+    it "updates secret of all keys in the file" do
+      expect(Keystorage::Manager).to receive_message_chain('new.exec')
+                                      .with(['mycommand','arg1','arg2'])
+      subject
+    end
+  end
+
+  describe "#version" do
+    let(:argv) { ['version'] }
+    let(:ver) {
+      File.read(File.join(File.dirname(__FILE__),'..','..','VERSION')).chomp
+    }
+    it "shows version" do
+      expect(STDOUT).to receive(:puts).with(ver).once
+      subject
+    end
+  end
+
 end

data/spec/keystorage/files/1.yml

@@ -0,0 +1,3 @@
+---
+"@":
+  sig: "abc"

data/spec/keystorage/manager_spec.rb

@@ -1,13 +1,383 @@
 require 'keystorage/manager'
+
+def yaml name
+  File.join(File.dirname(__FILE__),'files',"#{name}.yml")
+end
+
 describe Keystorage::Manager do
-  before {
-    @ks = Keystorage::Manager.new
-  }
-  subject { @ks.get("mygroup","key") }
-  it {
-    is_expected.to be ""
+  let(:files){
+    {
+      "1"=>{"@"=>{"sig"=>"abc"}},
+      "2"=>{"@"=>{"sig"=>"abc","token"=>"def"},"g1"=>{ "k1" => "abcdefg", "k2" =>"" },"g2"=>{}},
+    }
   }
+  before {  @manager = Keystorage::Manager.new }
+
+  # public methods
+  describe "#groups" do
+    subject { @manager.groups }
+    it "returns array of groups" do
+      allow(@manager).to receive(:file)
+                          .and_return(files["2"])
+      is_expected.to eq ["g1","g2"]
+    end
+  end
+
+  describe "#keys" do
+    subject { @manager.keys("g1") }
+    it "returns array of keys" do
+      allow(@manager).to receive(:file)
+                          .and_return(files["2"])
+
+      is_expected.to eq ["k1","k2"]
+    end
+  end
+
+  describe "#get" do
+    subject { @manager.get("g1","k1") }
+    before {
+      allow(@manager).to receive(:file)
+                          .and_return(files["2"])
+    }
+    context "has valid secret" do
+      before {
+        allow(@manager).to receive(:valid?)
+                            .and_return(true)
+      }
+      it "returns value of the key in the group" do
+        expect(@manager).to receive(:decode).with("abcdefg").once
+        subject
+      end
+    end
+    context "has no valid secret" do
+      before {
+        allow(@manager).to receive(:valid?)
+                          .and_return(false) }
+      it "raise Keystorage::SecretMissMatch" do
+        expect { subject }.to raise_error(Keystorage::SecretMissMatch)
+      end
+
+    end
+  end
+
+  describe "#set" do
+    before {
+      allow(@manager).to receive(:file)
+                          .and_return(files["2"])
+    }
+
+    context "group name '@'" do
+      subject { @manager.set("@","k1","v1") }
+      it "raise Keystorage::RejectGroupName" do
+        expect { subject }.to raise_error(Keystorage::RejectGroupName)
+      end
+    end
+
+    context "has valid secret" do
+      subject { @manager.set("g1","k1","v1") }
+      before {
+        allow(@manager).to receive(:valid?)
+                            .and_return(true)
+      }
+      it "sets the value to the key in the group" do
+        FakeFS do
+          subject
+          expect(@manager.get('g1','k1')).to eq "v1"
+        end
+      end
+    end
+
+    context "has no valid secret" do
+      subject { @manager.set("g1","k1","v1") }
+      before {
+        allow(@manager).to receive(:valid?)
+                            .and_return(false)
+      }
+      it "raise Keystorage::SecretMissMatch" do
+        expect { subject }.to raise_error(Keystorage::SecretMissMatch)
+      end
+
+    end
+  end
+
+  describe "#password" do
+    let(:new_password) { "zxcvbnm" }
+    subject { @manager.password(new_password) }
+
+    context "file not found" do
+      before {
+        @manager = Keystorage::Manager.new( {:file=>"hoge",:secret=>"fuga"})
+      }
+      it "creates new keystorage file" do
+        FakeFS do
+          subject
+          expect(File.exists?("hoge")).to eq true
+          expect(@manager.send(:file).has_key?("@")).to eq true
+        end
+      end
+    end
+
+    context "has valid secret" do
+
+      before {
+        @manager = Keystorage::Manager.new( {:file=>"hoge",:secret=>"fuga"})
+      }
+      it "updates password to `new_password`" do
+        FakeFS do
+          @manager.set("a","b","c")
+          subject
+          expect { @manager.get("a","b") }.to raise_error(Keystorage::SecretMissMatch)
+          @manager = Keystorage::Manager.new( {:file=>"hoge",:secret=>new_password})
+          expect(@manager.get("a","b")).to eq "c"
+        end
+      end
+    end
+
+    context "has no valid secret" do
+      before {
+        allow(@manager).to receive(:valid?)
+                            .and_return(false)
+      }
+      it "raise Keystorage::SecretMissMatch" do
+        expect { subject }.to raise_error(Keystorage::SecretMissMatch)
+      end
+
+    end
+  end
+
+  describe "#exec" do
+    let(:cmd) { ["ls","-a b"] }
+    subject { @manager.exec(cmd) }
+
+    context "has valid secret" do
+      before {
+        @manager = Keystorage::Manager.new( {:file=>"hoge",:secret=>"fuga"} )
+        allow(@manager).to receive(:valid?)
+                            .and_return(true)
+      }
+      it "execute command with env-vars" do
+        FakeFS do
+          @manager.set("a","b","c")
+          @manager.set("a","b","d e f")
+          @manager.set("x","y","z")
+
+          expect(@manager).to receive(:system)
+                             .with("a_b='d e f' x_y='z' ls -a b")
+                            .and_return(true)
+          subject
+        end
+      end
+    end
+
+    context "has no valid secret" do
+      before {
+        allow(@manager).to receive(:valid?)
+                            .and_return(false)
+      }
+      it "raise Keystorage::SecretMissMatch" do
+        expect { subject }.to raise_error(Keystorage::SecretMissMatch)
+      end
+
+    end
+  end
+
+
+  # private methods
+  describe "#sign" do
+    context "secret is nil" do
+      it "raise NoSecret" do
+        expect { @manager.send(:sign,"text",nil) }
+          .to raise_error(Keystorage::NoSecret)
+      end
+
+    end
+    context "secret is not nil" do
+      subject { @manager.send(:sign,"text","p@ssw0rd") }
+      it "returns sign" do
+        allow(OpenSSL::HMAC).to receive(:hexdigest)
+                                 .and_return("sample-sig")
+
+        is_expected.to eq "sample-sig"
+      end
+
+    end
+  end
+
+  describe "#token" do
+    subject { @manager.send(:token) }
+
+    it "returns token" do
+      allow(SecureRandom).to receive(:urlsafe_base64)
+                              .and_return("sample-token")
+      is_expected.to eq "sample-token"
+    end
+
+  end
+
+  describe "#root" do
+    context "file has '@' key" do
+      let(:root) { {"test1"=>"test2"} }
+      let(:data) { { "@" => root,"group1" => {"key1"=>"value1"} } }
+      subject { @manager.send(:root) }
+
+      it "returns Hash of root" do
+        allow(@manager).to receive(:file)
+                            .and_return(data)
+        is_expected.to eq root
+      end
+    end
+    context "file has no '@' key" do
+      let(:data) { { "group1" => {"key1"=>"value1"} } }
+      it "raise NoRootGroup" do
+        allow(@manager).to receive(:file)
+                            .and_return(data)
+
+        expect { @manager.send(:root) }
+          .to raise_error(Keystorage::NoRootGroup)
+      end
+
+    end
+  end
+
+  describe "#valid?" do
+    context "file has no root" do
+      subject { @manager.send(:valid?) }
+      let(:data) { { "group1" => {"key1"=>"value1"} } }
+      it "writes root and return true" do
+        allow(@manager).to receive(:file)
+                            .and_return(data)
+        allow(@manager).to receive(:write)
+                            .and_return(true)
+        expect(@manager).to receive(:write)
+        is_expected.to eq true
+      end
+    end
+  end
+
+  describe "#encode" do
+    let(:str) { "test message" }
+    let(:secret) { "s3cr3t" }
+    subject { @manager.send(:encode,str,secret) }
+    it "returns encoded string" do
+      is_expected.to eq "a191a5111cfee36a94bba4dc0a17c31d"
+    end
+  end
+
+  describe "#decode" do
+    let(:str) { "test message" }
+    let(:encoded) { "a191a5111cfee36a94bba4dc0a17c31d" }
+    let(:secret) { "s3cr3t" }
+    subject { @manager.send(:decode,encoded,secret) }
+    it "returns decoded string" do
+      is_expected.to eq str
+    end
+  end
+
+  describe "#file" do
+    subject { @manager.send(:file) }
+    it "returns data from path" do
+      allow(@manager).to receive(:path)
+                          .and_return(yaml("1"))
+      is_expected.to eq files["1"]
+    end
+  end
+
+  describe "#write" do
+    let(:data) { { :test => "rspec"} }
+    subject { @manager.send(:write,data) }
+    it "writes data to file" do
+      FakeFS do
+        expect { subject }.not_to raise_error
+        expect(@manager.send(:file).has_key?(:test)).to eq true
+      end
+    end
+  end
+
+  describe "#path" do
+    subject { @manager.send(:path) }
+    let(:file_path) { "abcdefgh" }
+
+    context "options[:path] is set" do
+      before{
+        allow(@manager).to receive(:options)
+                           .and_return({:file =>file_path})
+      }
+
+      it "returns options[:path]" do
+        is_expected.to eq file_path
+      end
+    end
+    context "options[:path] is not set" do
+      before {
+        allow(@manager).to receive(:options)
+                            .and_return({})
+      }
+
+      context "ENV KEYSTORAGE_FILE is set" do
+        before{
+          allow(ENV).to receive(:[])
+                         .with('KEYSTORAGE_FILE')
+                         .and_return(file_path)
+        }
+        it "returns KEYSTORAGE_FILE" do
+          is_expected.to eq file_path
+        end
+      end
+
+      context "ENV KEYSTORAGE_FILE is not set" do
+        before{
+          allow(ENV).to receive(:[])
+                         .with('KEYSTORAGE_FILE')
+                         .and_return(nil)
+        }
+        it "returns DEFAULT_FILE" do
+          is_expected.to eq Keystorage::DEFAULT_FILE
+        end
+      end
+    end
+
+  end
+
+  describe "#secret" do
+    subject { @manager.send(:secret) }
+    let(:password) { "abcedfg" }
+
+    context "options[:secret] is set" do
+      it "returns options[:secret]" do
+        allow(@manager).to receive(:options)
+                           .and_return({:secret =>password})
+        is_expected.to eq password
+      end
+    end
+    context "options[:secret] is not set" do
+      before {
+        allow(@manager).to receive(:options)
+                            .and_return({})
+      }
+      context "ENV KEYSTORAGE_SECRET is set" do
+        before {
+          allow(ENV).to receive(:[])
+                         .with('KEYSTORAGE_SECRET')
+                         .and_return(password)
+        }
+
+        it "returns secret ENV[:secret]" do
+          is_expected.to eq password
+        end
+      end
+      context "ENV KEYSTORAGE_SECRET is not set" do
+        before {
+          allow(ENV).to receive(:[])
+                         .with('KEYSTORAGE_SECRET')
+                         .and_return(nil)
+        }
+        it "returns DEFAULT_SECRET" do
+          is_expected.to eq Keystorage::DEFAULT_SECRET
+        end
+      end
+    end
+
+  end
 
+  after { FakeFS::FileSystem.clear }
 end
-  # ks = keystorage::Manager.new(:file =>"",:secret=> "P@ssword")
-  # ks.get("mygroup","mykey") # => "mysecret"

data/spec/keystorage_spec.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+require 'keystorage'
+
+describe Keystorage do
+  let(:test_class) { Struct.new(:a){ include Keystorage } }
+  subject { test_class.new  }
+
+  describe "#render" do
+
+    context "Unknown format ':unknown' given" do
+      let(:format) { :unknown }
+      let(:string) { SecureRandom.urlsafe_base64(nil, false) }
+      it "raises Keystorage::FormatNotSupport" do
+        expect { subject.render(string,format) }.to raise_error(Keystorage::FormatNotSupport)
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -1,3 +1,12 @@
+# coding: utf-8
+require 'simplecov'
+require "codeclimate-test-reporter"
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  CodeClimate::TestReporter::Formatter
+]
+SimpleCov.start
+
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
 # The generated `.rspec` file contains `--require spec_helper` which will cause
@@ -89,3 +98,4 @@ RSpec.configure do |config|
   Kernel.srand config.seed
 =end
 end
+require 'fakefs/spec_helpers'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: keystorage
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.7
 platform: ruby
 authors:
 - Yoshihiro TAKAHARA
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: version
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -53,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: version
+  name: fakefs
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -76,6 +90,7 @@ extra_rdoc_files:
 files:
 - ".gitignore"
 - ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -87,10 +102,10 @@ files:
 - lib/keystorage/cli.rb
 - lib/keystorage/manager.rb
 - spec/keystorage/cli_spec.rb
+- spec/keystorage/files/1.yml
 - spec/keystorage/manager_spec.rb
+- spec/keystorage_spec.rb
 - spec/spec_helper.rb
-- test/helper.rb
-- test/test_keystorage.rb
 homepage: http://github.com/tumf/keystorage
 licenses:
 - MIT
@@ -117,8 +132,8 @@ specification_version: 4
 summary: Simple password storage
 test_files:
 - spec/keystorage/cli_spec.rb
+- spec/keystorage/files/1.yml
 - spec/keystorage/manager_spec.rb
+- spec/keystorage_spec.rb
 - spec/spec_helper.rb
-- test/helper.rb
-- test/test_keystorage.rb
 has_rdoc: 

data/test/helper.rb

@@ -1,18 +0,0 @@
-require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'test/unit'
-require 'shoulda'
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'keystorage'
-
-class Test::Unit::TestCase
-end

data/test/test_keystorage.rb

@@ -1,36 +0,0 @@
-require 'helper'
-require 'fileutils'
-
-class TestKeystorage < Test::Unit::TestCase
-  @@file = ".testkey"
-  context "set / delete"  do
-    setup do
-      Keystorage.set("abc","def","ghi",@@file)
-      Keystorage.set("abc","123","456",@@file)
-    end
-    teardown do
-      FileUtils.rm(@@file)
-    end
-
-    should "file exists" do
-      assert File.exists?(@@file)
-    end
-
-    should "exist def and 123" do
-      assert_equal "ghi",Keystorage.get("abc","def",@@file)
-      assert_equal "456",Keystorage.get("abc","123",@@file)
-    end
-
-    should "delete only def" do
-      Keystorage.delete("abc","def",@@file)
-      assert_equal "456",Keystorage.get("abc","123",@@file)
-      assert_equal false,Keystorage.get("abc","def",@@file)
-    end
-
-    should "delete abc group" do
-      Keystorage.delete("abc",nil,@@file)
-      assert_equal false,Keystorage.get("abc","123",@@file)
-      assert_equal false,Keystorage.get("abc","def",@@file)
-    end
-  end
-end