cifrado 0.1

data/tests/file_splitter_tests.rb

@@ -0,0 +1,61 @@
+Shindo.tests('Cifrado | FileSplitter') do
+  
+  obj = create_bin_payload 1
+  obj10 = create_bin_payload 10*1024
+  obj100 = create_bin_payload 100*1024
+
+  tests('#split') do
+
+    tests('10MB file') do
+      s = FileSplitter.new obj10, 10
+      count = 1
+      chunks = s.split
+      chunks.each do |chunk|
+        test "generates chunk ##{count}" do
+          File.exist?(chunk)
+        end
+        test "the chunk #{chunk} has the correct size" do
+          # Each chunk is 1K
+          File.size(chunk) == 1024*1024
+        end
+        count += 1
+      end
+      
+      test 'md5 matches' do
+        t = tmpfile
+        chunks.each do |c|
+          `/bin/cat #{c} >> #{t}`
+        end
+        Digest::MD5.file(t) == Digest::MD5.file(obj10)
+      end
+    end
+
+    test '8KB file' do
+      s = FileSplitter.new create_bin_payload(8), 2
+      s.split.size == 2
+    end
+    
+    test '10KB file' do
+      s = FileSplitter.new create_bin_payload(10), 4
+      s.split.size == 3
+    end
+
+    test 'split 1K in 2 returns 1 chunk' do
+      s = FileSplitter.new obj, 2
+      s.split.size == 1
+    end
+
+    test 'calculate chunks' do
+      s = FileSplitter.new obj100
+      s.split.size == 10 
+    end
+    
+    test 'discard-chunks' do
+      s = FileSplitter.new obj100, 30
+      chunks = s.split
+      chunks.size == 30
+    end
+    
+  end
+
+end

data/tests/helper.rb

@@ -0,0 +1,117 @@
+require 'cifrado'
+require 'yaml'
+require 'securerandom'
+require 'fileutils'
+require 'digest/md5'
+
+include Cifrado
+include Cifrado::Utils
+  
+unless ENV['DEBUG']
+  Cifrado::Log.level = Logger::ERROR
+end
+
+def client
+  conf = YAML.load_file File.expand_path("~/.config/cifrado/cifradorc")
+  client = SwiftClient.new  :username => conf[:username],
+                            :api_key  => conf[:password],
+                            :auth_url => conf[:auth_url],
+                            :region   => conf[:region],
+                            :password_salt => conf[:secure_random],
+                            :connection_options => { :ssl_verify_peer => false }
+end
+
+def create_tmpdir
+  dir = "/tmp/cifrado-#{SecureRandom.hex}"
+  Dir.mkdir dir
+  dir
+end
+
+def test_container
+  client.service.directories.create :key => test_container_name
+end
+
+def test_container_name
+  'cifrado-tests'
+end
+
+def test_container_segments_name
+  'cifrado-tests_segments'
+end
+
+def test_container_segments
+  client.service.directories.create :key => test_container_segments_name
+end
+
+def populate_tmpdir
+  tmpdir = create_tmpdir
+  create_bin_payload 100, "#{tmpdir}/#{SecureRandom.hex}"
+  create_bin_payload 100, "#{tmpdir}/#{SecureRandom.hex}"
+  create_bin_payload 100, "#{tmpdir}/#{SecureRandom.hex}"
+  tmpdir
+end
+
+# Size in KB
+def create_bin_payload size, filename = nil
+  if filename
+    tmp_file = filename
+  else
+    tmp_file = "/tmp/cifrado-test-payload-#{SecureRandom.hex}"
+  end
+  target_dir = File.dirname(tmp_file)
+  unless File.directory?(target_dir)
+    FileUtils.mkdir_p target_dir
+  end
+  out = `dd if=/dev/urandom of=#{tmp_file} bs=1K count=#{size} > /dev/null 2>&1`
+  raise "Error creating #{size}MB binary payload" unless $? == 0
+  tmp_file
+end
+
+def create_text_payload text
+  tmp_file = "/tmp/cifrado-test-payload-#{SecureRandom.hex}"
+  File.open tmp_file, 'w' do |f|
+    f.puts text
+  end
+  tmp_file
+end
+
+def clean_test_payloads
+  Dir["/tmp/cifrado-test-payload-*"].each do |f|
+    File.delete f
+  end
+end
+
+def clean_test_container
+  if dir = test_container
+    dir.files.each do |f|
+      f.destroy
+    end
+  end
+  if dir = test_container_segments
+    dir.files.each do |f|
+      f.destroy
+    end
+  end
+end
+
+def passphrase
+  'foobar'
+end
+
+def cleanup
+  clean_test_payloads
+  clean_test_container
+  Dir["/tmp/cifrado*"].each { |f| FileUtils.rm_rf f }
+  Dir[File.join(ENV['HOME'], ".cache/cifrado") + "/*segments*"].each { |f| FileUtils.rm_rf f }
+end
+
+def tmpfile
+  "/tmp/cifrado-tests-#{SecureRandom.hex}"
+end
+
+at_exit do
+  puts "Cleaning up..."
+  cleanup
+  test_container_segments.destroy
+  test_container.destroy
+end

data/tests/swift_client/create_directory.rb

@@ -0,0 +1,14 @@
+Shindo.tests('Cifrado | SwiftClient#create_directory') do
+
+  tests '#create_directory' do
+    name = SecureRandom.hex
+    dir = client.create_directory name
+    test 'is a Fog::Storage::OpenStack::Directory' do
+      dir.is_a? Fog::Storage::OpenStack::Directory
+    end
+    test "dir name is #{name}" do
+      dir.key == name 
+    end
+  end
+
+end

data/tests/swift_client/download_tests.rb

@@ -0,0 +1,208 @@
+Shindo.tests('Cifrado | SwiftClient#download') do
+    
+  cwd = Dir.pwd
+  cli_options = {
+    :insecure => true,
+    :no_progressbar => true
+  }
+
+  tests "#download" do
+    test "object" do
+      obj = create_bin_payload 1
+      md5 = Digest::MD5.file obj
+      client.upload('cifrado-tests', obj) 
+      output = "/tmp/cifrado-tests-#{SecureRandom.hex}"
+      r = client.download 'cifrado-tests', 
+                          obj,
+                          :output => output
+      r.status == 200 and Digest::MD5.file(output) == md5
+    end
+    
+    tests "download and decrypt" do
+      test 'with output option' do
+        obj = create_text_payload 'foobar'
+        md5 = Digest::MD5.file obj
+        output = "/tmp/cifrado-tests-#{SecureRandom.hex}"
+        cli = Cifrado::CLI.new
+        cli.options = cli_options.merge({
+          :encrypt  => 'a:rubiojr',
+        })
+        obj_path = cli.upload test_container_name, obj
+        r = client.download test_container_name, 
+                            obj_path,
+                            :output => output,
+                            :decrypt => true
+        r.status == 200 and \
+          Digest::MD5.file(output) == md5 and \
+          File.read(output).strip.chomp == 'foobar'
+      end
+
+      test 'witout output' do
+        obj = create_text_payload 'foobar'
+        md5 = Digest::MD5.file obj
+        output = "/tmp/cifrado-tests-#{SecureRandom.hex}"
+        Dir.mkdir output
+        Dir.chdir output
+        cli = Cifrado::CLI.new
+        cli.options = cli_options.merge({
+          :encrypt  => 'a:rubiojr',
+        })
+        obj_path = cli.upload test_container_name, obj
+        r = client.download test_container_name, 
+                            obj_path,
+                            :decrypt => true
+        downloaded_file = File.join(output, obj)
+        r.status == 200 and \
+          Digest::MD5.file(downloaded_file) == md5 and \
+          File.read(downloaded_file).strip.chomp == 'foobar'
+      end
+      Dir.chdir cwd
+
+      test 'not really encrypted' do
+        obj = create_text_payload 'foobar'
+        md5 = Digest::MD5.file obj
+        output = "/tmp/cifrado-tests-#{SecureRandom.hex}"
+        Dir.mkdir output
+        Dir.chdir output
+        cli = Cifrado::CLI.new
+        cli.options = cli_options
+        obj_path = cli.upload test_container_name, obj
+        r = client.download test_container_name, 
+                            obj_path,
+                            :decrypt => true
+        downloaded_file = File.join(output, obj)
+        r.status == 200 and \
+          Digest::MD5.file(downloaded_file) == md5 and \
+          File.read(downloaded_file).strip.chomp == 'foobar'
+      end
+      Dir.chdir cwd
+
+      tests 'container' do
+        clean_test_container
+
+        container = test_container
+        obj = create_bin_payload 1
+        obj2 = create_bin_payload 1
+        obj3 = create_bin_payload 1, tmpfile + "/foo/bar/file1"
+        output = "/tmp/cifrado-objects-#{SecureRandom.hex}"
+        cli = Cifrado::CLI.new
+        cli.options = cli_options.merge({
+          :segments => 3,
+          :encrypt => "s:#{passphrase}"
+        })
+        [obj, obj2, obj3].each do |o|
+          cli.upload container.key, o
+        end
+        sleep 5
+        
+        raises ArgumentError, 'download to invalid dir' do
+          client.download container.key, 
+                          nil, 
+                          :output => output,
+                          :decrypt => true,
+                          :passphrase => passphrase
+        end
+
+        tests "contents in #{output}" do
+          FileUtils.mkdir output
+          returns(Excon::Response,"download contents to #{output}") do
+            client.download(container.key, 
+                            nil, 
+                            :output => output,
+                            :decrypt => true,
+                            :passphrase => passphrase).class
+          end
+          [obj, obj2, obj3].each do |o|
+            test "includes #{o}" do
+              Dir["#{output}/**/*"].include?(File.join(output, obj))
+            end
+          end
+          test "file #{obj3} exist" do
+            File.exist?(File.join(output, obj3))
+          end
+        end
+
+        tests 'file MD5 digest' do
+          hashes = []
+          hashes << Digest::MD5.file(obj)
+          hashes << Digest::MD5.file(obj2)
+          hashes << Digest::MD5.file(obj3)
+          Dir["#{output}/**/*"].each do |f|
+            next if File.directory?(f)
+            digest = Digest::MD5.file(f)
+            test "includes #{digest}" do
+              hashes.include?(digest)
+            end
+          end
+        end
+      end
+
+    end
+
+    test "to current dir" do
+      obj = create_bin_payload 1
+      md5 = Digest::MD5.file obj
+      client.upload(test_container_name, obj) 
+      cwd = Dir.pwd
+      Dir.mkdir '/tmp/cifrado'
+      Dir.chdir '/tmp/cifrado'
+      r = client.download test_container_name,
+                          obj
+      file = File.join(Dir.pwd, obj)
+      Digest::MD5.file(file) == md5 
+    end
+    Dir.chdir cwd
+
+    test 'segmented file' do
+      obj = create_bin_payload 1
+      md5 = Digest::MD5.file obj
+      cli = Cifrado::CLI.new
+      cli.options = cli_options.merge({
+        :segments => 3
+      })
+      segments = cli.upload 'cifrado-tests', obj
+      sleep 5
+      output = "/tmp/cifrado-tests-#{SecureRandom.hex}"
+      r = client.download 'cifrado-tests', 
+                          obj,
+                          :output => output
+      r.status == 200 and Digest::MD5.file(output) == md5
+    end
+
+    cleanup
+
+    test 'container' do
+      container = test_container
+      obj = create_bin_payload 1
+      obj2 = create_bin_payload 1
+      cli = Cifrado::CLI.new
+      cli.options = cli_options.merge({
+        :segments => 3,
+      })
+      cli.upload container.key, obj
+      cli.upload container.key, obj2
+      sleep 5
+      output = "/tmp/cifrado-objects-#{SecureRandom.hex}"
+      FileUtils.mkdir output
+      client.download container.key, nil, :output => output
+      Dir["#{output}/**/*"].size == 3
+    end
+    
+    tests "progress callback" do
+      obj = create_bin_payload 1
+      chunks = []
+      cb = Proc.new do |length, read, data|
+        chunks << read
+      end
+      client.upload test_container_name, obj
+      client.download test_container_name, 
+                      obj, 
+                      :output => tmpfile,
+                      :progress_callback => cb
+      test "chunks equal File.size" do
+        File.size(obj) == chunks.inject(:+)
+      end
+    end
+  end
+
+end

data/tests/swift_client/file_available.rb

@@ -0,0 +1,25 @@
+Shindo.tests('Cifrado | SwiftClient#file_available?') do
+
+  obj1 = create_bin_payload 1
+  clean_object = clean_object_name(obj1)
+  tests 'success' do
+    test "object #{clean_object} available in #{test_container_name}" do
+      client.upload test_container_name, obj1
+      client.file_available? test_container_name, clean_object
+    end
+    test "object #{obj1} available in #{test_container_name}" do
+      client.upload test_container_name, obj1
+      !client.file_available? test_container_name, obj1
+    end
+  end 
+  tests 'failures' do
+    container = SecureRandom.hex
+    test "object #{obj1} not available in #{container}" do
+      !(client.file_available? container, clean_object)
+    end
+    test "object #{container} not available in #{test_container_name}" do
+      !(client.file_available? test_container_name, container)
+    end
+  end 
+
+end

data/tests/swift_client/head_tests.rb

@@ -0,0 +1,34 @@
+Shindo.tests('Cifrado | SwiftClient#head') do
+
+  obj1 = create_bin_payload 1
+  clean_object = clean_object_name(obj1)
+  tests 'head object' do
+    test "object #{clean_object} headers available" do
+      client.upload test_container_name, obj1
+      (client.head test_container_name, clean_object_name(obj1)).is_a?(Hash)
+    end
+    test 'head invalid object' do
+      client.head(test_container_name, SecureRandom.hex).nil?
+    end
+  end
+  tests 'head account' do
+    test "head account bytes" do
+      !client.head['X-Account-Bytes-Used'].nil? 
+    end
+    test "head account bytes" do
+      client.head['X-Account-Object-Count'].to_i >= 0
+    end
+  end
+  tests 'head container' do
+    test "head container bytes" do
+      !client.head(test_container_name)['X-Container-Bytes-Used'].nil? 
+    end
+    test "head container bytes" do
+      client.head(test_container_name)['X-Container-Object-Count'].to_i >= 0
+    end
+    test 'head invalid container' do
+      client.head(SecureRandom.hex).nil?
+    end
+  end 
+
+end