fog-local 0.1.0

data/tests/helpers/mock_helper.rb

@@ -0,0 +1,7 @@
+# Use so you can run in mock mode from the command line
+#
+# FOG_MOCK=true fog
+
+if ENV["FOG_MOCK"] == "true"
+  Fog.mock!
+end

data/tests/helpers/model_helper.rb

@@ -0,0 +1,31 @@
+def model_tests(collection, params = {}, mocks_implemented = true)
+  tests('success') do
+
+    @instance = collection.new(params)
+
+    tests("#save").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      @instance.save
+    end
+
+    if block_given?
+      yield(@instance)
+    end
+
+    tests("#destroy").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      @instance.destroy
+    end
+
+  end
+end
+
+# Generates a unique identifier with a random differentiator.
+# Useful when rapidly re-running tests, so we don't have to wait
+# serveral minutes for deleted objects to disappear from the API
+# E.g. 'fog-test-1234'
+def uniq_id(base_name = 'fog-test')
+  # random_differentiator
+  suffix = rand(65536).to_s(16).rjust(4, '0')
+  [base_name, suffix] * '-'
+end

data/tests/helpers/schema_validator_tests.rb

@@ -0,0 +1,107 @@
+Shindo.tests('Fog::Schema::DataValidator', 'meta') do
+
+  validator = Fog::Schema::DataValidator.new
+
+  tests('#validate') do
+
+    tests('returns true') do
+
+      returns(true, 'when value matches schema expectation') do
+        validator.validate({"key" => "Value"}, {"key" => String})
+      end
+
+      returns(true, 'when values within an array all match schema expectation') do
+        validator.validate({"key" => [1, 2]}, {"key" => [Integer]})
+      end
+
+      returns(true, 'when nested values match schema expectation') do
+        validator.validate({"key" => {:nested_key => "Value"}}, {"key" => {:nested_key => String}})
+      end
+
+      returns(true, 'when collection of values all match schema expectation') do
+        validator.validate([{"key" => "Value"}, {"key" => "Value"}], [{"key" => String}])
+      end
+
+      returns(true, 'when collection is empty although schema covers optional members') do
+        validator.validate([], [{"key" => String}])
+      end
+
+      returns(true, 'when additional keys are passed and not strict') do
+        validator.validate({"key" => "Value", :extra => "Bonus"}, {"key" => String}, {:allow_extra_keys => true})
+      end
+
+      returns(true, 'when value is nil and schema expects NilClass') do
+        validator.validate({"key" => nil}, {"key" => NilClass})
+      end
+
+      returns(true, 'when value and schema match as hashes') do
+        validator.validate({}, {})
+      end
+
+      returns(true, 'when value and schema match as arrays') do
+        validator.validate([], [])
+      end
+
+      returns(true, 'when value is a Time') do
+        validator.validate({"time" => Time.now}, {"time" => Time})
+      end
+
+      returns(true, 'when key is missing but value should be NilClass (#1477)') do
+        validator.validate({}, {"key" => NilClass}, {:allow_optional_rules => true})
+      end
+
+      returns(true, 'when key is missing but value is nullable (#1477)') do
+        validator.validate({}, {"key" => Fog::Nullable::String}, {:allow_optional_rules => true})
+      end
+
+    end
+
+    tests('returns false') do
+
+      returns(false, 'when value does not match schema expectation') do
+        validator.validate({"key" => nil}, {"key" => String})
+      end
+
+      returns(false, 'when key formats do not match') do
+        validator.validate({"key" => "Value"}, {:key => String})
+      end
+
+      returns(false, 'when additional keys are passed and strict') do
+        validator.validate({"key" => "Missing"}, {})
+      end
+
+      returns(false, 'when some keys do not appear') do
+        validator.validate({}, {"key" => String})
+      end
+
+      returns(false, 'when collection contains a member that does not match schema') do
+        validator.validate([{"key" => "Value"}, {"key" => 5}], [{"key" => String}])
+      end
+
+      returns(false, 'when collection has multiple schema patterns') do
+        validator.validate([{"key" => "Value"}], [{"key" => Integer}, {"key" => String}])
+      end
+
+      returns(false, 'when hash and array are compared') do
+        validator.validate({}, [])
+      end
+
+      returns(false, 'when array and hash are compared') do
+        validator.validate([], {})
+      end
+
+      returns(false, 'when a hash is expected but another data type is found') do
+        validator.validate({"key" => {:nested_key => []}}, {"key" => {:nested_key => {}}})
+      end
+
+      returns(false, 'when key is missing but value should be NilClass (#1477)') do
+        validator.validate({}, {"key" => NilClass}, {:allow_optional_rules => false})
+      end
+
+      returns(false, 'when key is missing but value is nullable (#1477)') do
+        validator.validate({}, {"key" => Fog::Nullable::String}, {:allow_optional_rules => false})
+      end
+
+    end
+  end
+end

data/tests/helpers/succeeds_helper.rb

@@ -0,0 +1,9 @@
+module Shindo
+  class Tests
+    def succeeds
+      test('succeeds') do
+        !!instance_eval(&Proc.new)
+      end
+    end
+  end
+end

data/tests/local/models/directories_tests.rb

@@ -0,0 +1,17 @@
+Shindo.tests('Storage[:local] | directories', ["local"]) do
+
+  pending if Fog.mocking?
+
+  @options = { :local_root => "/tmp/fogtests" }
+  @collection = Fog::Storage::Local.new(@options).directories
+
+  collection_tests(@collection, {:key => "fogdirtests"}, true)
+
+  tests("#all") do
+    tests("succeeds when :local_root does not exist").succeeds do
+      FileUtils.rm_rf(@options[:local_root])
+      @collection.all
+    end
+  end
+
+end

data/tests/local/models/directory_tests.rb

@@ -0,0 +1,16 @@
+Shindo.tests('Storage[:local] | directory', ["local"]) do
+
+  pending if Fog.mocking?
+
+  before do
+    @options = { :local_root => '~/.fog' }
+  end
+
+  tests('save') do
+    returns(true) do
+      connection = Fog::Storage::Local.new(@options)
+      connection.directories.create(:key => 'directory')
+      connection.directories.create(:key => 'directory')
+    end
+  end
+end

data/tests/local/models/file_tests.rb

@@ -0,0 +1,43 @@
+Shindo.tests('Storage[:local] | file', ["local"]) do
+
+  pending if Fog.mocking?
+
+  before do
+    @options = { :local_root => '~/.fog' }
+  end
+
+  tests('#public_url') do
+    tests('when connection has an endpoint').
+      returns('http://example.com/files/directory/file.txt') do
+        @options[:endpoint] = 'http://example.com/files'
+
+        connection = Fog::Storage::Local.new(@options)
+        directory = connection.directories.new(:key => 'directory')
+        file = directory.files.new(:key => 'file.txt')
+
+        file.public_url
+      end
+
+    tests('when connection has no endpoint').
+      returns(nil) do
+        @options[:endpoint] = nil
+
+        connection = Fog::Storage::Local.new(@options)
+        directory = connection.directories.new(:key => 'directory')
+        file = directory.files.new(:key => 'file.txt')
+
+        file.public_url
+      end
+
+    tests('when file path has escapable characters').
+      returns('http://example.com/files/my%20directory/my%20file.txt') do
+        @options[:endpoint] = 'http://example.com/files'
+
+        connection = Fog::Storage::Local.new(@options)
+        directory = connection.directories.new(:key => 'my directory')
+        file = directory.files.new(:key => 'my file.txt')
+
+        file.public_url
+      end
+  end
+end

data/tests/local/storage_tests.rb

@@ -0,0 +1,40 @@
+Shindo.tests('Local | storage') do
+
+  pending if Fog.mocking?
+
+  before do
+    @options = { :local_root => "~/.fog" }
+  end
+
+  tests('#endpoint') do
+    tests('when no endpoint is provided').
+      returns(nil) do
+        Fog::Storage::Local.new(@options).endpoint
+      end
+
+    tests('when no host is provided').
+      returns(nil) do
+        @options[:scheme] = 'http'
+        @options[:path] = '/files'
+        @options[:port] = 80
+
+        Fog::Storage::Local.new(@options).endpoint
+      end
+
+    tests('when endpoint is provided').
+      returns('http://example.com/files') do
+        @options[:endpoint] = 'http://example.com/files'
+
+        Fog::Storage::Local.new(@options).endpoint
+      end
+
+    tests('when at least host option is provided').
+      returns('http://example.com/files') do
+        @options[:scheme] = 'http'
+        @options[:host] = 'example.com'
+        @options[:path] = '/files'
+
+        Fog::Storage::Local.new(@options).endpoint
+      end
+  end
+end

data/tests/watchr.rb

@@ -0,0 +1,22 @@
+ENV['FOG_MOCK'] ||= 'true'
+ENV['AUTOTEST'] = 'true'
+ENV['WATCHR']   = '1'
+
+def file2shindo(file)
+  result = file.sub('lib/fog/', 'tests/').gsub(/\.rb$/, '_tests.rb')
+end
+
+def run_shindo_test(file)
+  if File.exist? file
+    system("shindont #{file}")
+  else
+    puts "FIXME: No test #{file} [#{Time.now}]"
+  end
+end
+
+watch( 'tests/.*_tests\.rb' ) do |md|
+  run_shindo_test(md[0])
+end
+watch( 'lib/.*\.rb' ) do |md|
+  run_shindo_test(file2shindo(md[0]))
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: fog-local
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Wesley Beary
+- Ville Lautanala
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: shindo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: fog-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.27'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.27'
+description: |-
+  This library can be used as a module for `fog` or as standalone provider
+                         to use local filesystem storage.
+email:
+- geemus@gmail.com
+- lautis@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CONTRIBUTING.md
+- CONTRIBUTORS.md
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- fog-local.gemspec
+- lib/fog-local.rb
+- lib/fog/bin/local.rb
+- lib/fog/local.rb
+- lib/fog/local/core.rb
+- lib/fog/local/models/storage/directories.rb
+- lib/fog/local/models/storage/directory.rb
+- lib/fog/local/models/storage/file.rb
+- lib/fog/local/models/storage/files.rb
+- lib/fog/local/storage.rb
+- lib/fog/local/version.rb
+- tests/helper.rb
+- tests/helpers/collection_helper.rb
+- tests/helpers/formats_helper.rb
+- tests/helpers/formats_helper_tests.rb
+- tests/helpers/mock_helper.rb
+- tests/helpers/model_helper.rb
+- tests/helpers/schema_validator_tests.rb
+- tests/helpers/succeeds_helper.rb
+- tests/local/models/directories_tests.rb
+- tests/local/models/directory_tests.rb
+- tests/local/models/file_tests.rb
+- tests/local/storage_tests.rb
+- tests/watchr.rb
+homepage: https://github.com/fog/fog-local
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Module for the 'fog' gem to support local filesystem storage.
+test_files: []