usmu-s3 1.0.0

data/spec/s3/s3_configuration_spec.rb

@@ -0,0 +1,106 @@
+require 'usmu/s3/s3_configuration'
+require 'ostruct'
+
+RSpec.describe Usmu::S3::S3Configuration do
+  let (:empty_configuration) { Usmu::S3::S3Configuration.new({}) }
+  let (:configuration) {
+    Usmu::S3::S3Configuration.new(
+        {
+            'region' => '%env{TEST_REGION}',
+            'access key' => 'replace %env{TEST_ACCESS_KEY}',
+            'secret key' => 'replace %env{TEST_SECRET_KEY}',
+            'bucket' => 'replace %env{TEST_BUCKET}',
+        }
+    )
+  }
+
+  before do
+    allow(ENV).to receive(:'[]').with('AWS_REGION').and_return('us-east-1')
+    allow(ENV).to receive(:'[]').with('AWS_ACCESS_KEY_ID').and_return('access_key_test')
+    allow(ENV).to receive(:'[]').with('AWS_SECRET_ACCESS_KEY').and_return('secret_key_test')
+    allow(ENV).to receive(:'[]').with('TEST_REGION').and_return('ap-southeast-2')
+    allow(ENV).to receive(:'[]').with('TEST_ACCESS_KEY').and_return('access_key_test')
+    allow(ENV).to receive(:'[]').with('TEST_SECRET_KEY').and_return('secret_key_test')
+    allow(ENV).to receive(:'[]').with('TEST_BUCKET').and_return('example.com')
+  end
+
+  context '#inspect' do
+    it 'does show class name' do
+      expect(configuration.inspect.start_with? '#<Usmu::S3::S3Configuration ').to eq(true)
+    end
+
+    it 'does show region' do
+      expect(configuration.inspect.match(/ region="ap-southeast-2"/)).to_not eq(nil)
+    end
+
+    it 'does show access_key' do
+      expect(configuration.inspect.match(/ access_key="replace access_key_test"/)).to_not eq(nil)
+    end
+
+    it "doesn't show secret_key" do
+      expect(configuration.inspect.match(/ secret_key="/)).to eq(nil)
+    end
+
+    it 'does show bucket' do
+      expect(configuration.inspect.match(/ bucket="replace example.com"/)).to_not eq(nil)
+    end
+  end
+
+  context '#region' do
+    it 'uses AWS SDK environment variables for defaults' do
+      expect(empty_configuration.region).to eq('us-east-1')
+    end
+
+    it 'replaces environment variables' do
+      expect(configuration.region).to eq('ap-southeast-2')
+    end
+  end
+
+  context '#access_key' do
+    it 'uses AWS SDK environment variables for defaults' do
+      expect(empty_configuration.access_key).to eq('access_key_test')
+    end
+
+    it 'replaces environment variables' do
+      expect(configuration.access_key).to eq('replace access_key_test')
+    end
+  end
+
+  context '#secret_key' do
+    it 'uses AWS SDK environment variables for defaults' do
+      expect(empty_configuration.secret_key).to eq('secret_key_test')
+    end
+
+    it 'replaces environment variables' do
+      expect(configuration.secret_key).to eq('replace secret_key_test')
+    end
+  end
+
+  context '#bucket' do
+    it 'has a default value of an empty string' do
+      expect(empty_configuration.bucket).to eq('')
+    end
+
+    it 'replaces environment variables' do
+      expect(configuration.bucket).to eq('replace example.com')
+    end
+  end
+
+  context '#substitute_env' do
+    it 'replaces environment variables' do
+      expect(empty_configuration.send :substitute_env, '%env{AWS_REGION}').to eq('us-east-1')
+    end
+
+    it 'replaces multiple environment variables' do
+      expect(empty_configuration.send :substitute_env, '%env{AWS_REGION},%env{TEST_REGION}').to eq('us-east-1,ap-southeast-2')
+    end
+  end
+
+  context '#credentials' do
+    it 'returns a new Aws::Credentials from it\'s settings' do
+      creds = OpenStruct.new {}
+      allow(Aws::Credentials).to receive(:new).with('access_key_test', 'secret_key_test').and_return(creds)
+      expect(empty_configuration.credentials).to eq(creds)
+    end
+  end
+end

data/spec/s3/uploader_spec.rb

@@ -0,0 +1,92 @@
+require 'usmu/configuration'
+require 'usmu/s3/s3_configuration'
+require 'usmu/s3/uploader'
+require 'usmu/s3_service_mock'
+require 'ostruct'
+
+RSpec.describe Usmu::S3::Uploader do
+  let (:configuration) { Usmu::Configuration.from_hash({}) }
+  let (:s3_configuration) {
+    Usmu::S3::S3Configuration.new(
+        {
+            'access key' => 'access',
+            'secret key' => 'secret',
+            'region' => 'us-east-1',
+            'bucket' => 'bucket',
+        }
+    )
+  }
+  let (:creds) { OpenStruct.new({ access_key: 'access', secret_key: 'secret' }) }
+  let (:s3) { Usmu::S3ServiceMock.new([]) }
+  let (:uploader) { Usmu::S3::Uploader.new(configuration, s3_configuration) }
+
+  before do
+    expect(s3_configuration).to receive(:credentials).and_return(creds)
+    expect(Aws::S3::Resource).to receive(:new).with({credentials: creds, region: 'us-east-1'}).and_return(s3)
+  end
+
+  context '#initialize' do
+    it 'sets up instance variables' do
+      expect(uploader.send :configuration).to eq(configuration)
+      expect(uploader.send :bucket).to eq(s3)
+      expect(s3.get_bucket).to eq('bucket')
+      expect(uploader.send(:log).is_a? Logging::Logger).to eq(true)
+      expect(uploader.send(:log).name).to eq(described_class.name)
+    end
+  end
+
+  context '#push' do
+    it 'pushes new and updated files and deletes old files' do
+      expect(uploader).to receive(:push_local).with(['local.html'])
+      expect(uploader).to receive(:push_local).with(['updated.html'])
+      expect(uploader).to receive(:delete_remote).with(['remote.html'])
+
+      uploader.push({
+                        local: ['local.html'],
+                        updated: ['updated.html'],
+                        remote: ['remote.html'],
+                    })
+    end
+  end
+
+  context '#push_local' do
+    let (:io) { OpenStruct.new {} }
+
+    before do
+      allow(File).to receive(:open).with('site/local.html', 'r').and_yield(io)
+    end
+
+    it 'sends a request to S3 to push named files' do
+      expect(s3).to receive(:put_object).with({key: 'local.html', body: io})
+      uploader.send :push_local, ['local.html']
+    end
+
+    it 'logs files as they are pushed' do
+      uploader.send :push_local, ['local.html']
+      expect(@log_output.readline).to eq("SUCCESS  Usmu::S3::Uploader : Uploading local.html\n")
+    end
+  end
+
+  context '#delete_remote' do
+    it 'sends a request to S3 to delete named files' do
+      expect(s3).to receive(:delete_objects).with({delete: {objects: [{key: 'remote.html'}]}})
+      uploader.send :delete_remote, ['remote.html']
+    end
+
+    it 'sends requests in batches of 1000' do
+      expect(s3).to receive(:delete_objects).with({delete: {objects: (0...1000).map {|f| {key: "#{f}.html"}}}})
+      expect(s3).to receive(:delete_objects).with({delete: {objects: (1000..1100).map {|f| {key: "#{f}.html"}}}})
+      uploader.send(:delete_remote, (0..1100).map {|f| "#{f}.html"})
+    end
+
+    it 'only sends one request if we have exactly one batch of files' do
+      expect(s3).to receive(:delete_objects).with({delete: {objects: (0...1000).map {|f| {key: "#{f}.html"}}}})
+      uploader.send(:delete_remote, (0...1000).map {|f| "#{f}.html"})
+    end
+
+    it 'logs files as they are deleted' do
+      uploader.send :delete_remote, ['remote.html']
+      expect(@log_output.readline).to eq("SUCCESS  Usmu::S3::Uploader : Deleting remote.html\n")
+    end
+  end
+end

data/spec/s3_spec.rb

@@ -0,0 +1,110 @@
+require 'usmu/s3'
+require 'usmu/configuration'
+require 'usmu/uploader_mock'
+require 'usmu/commander_mock'
+require 'ostruct'
+
+RSpec.describe Usmu::S3 do
+  let(:plugin) { Usmu::S3.new }
+  let(:commander) { Usmu::CommanderMock.new }
+
+  context '#initialize' do
+    it 'configures logging' do
+      expect(plugin.send(:log).is_a? Logging::Logger).to eq(true)
+      expect(plugin.send(:log).name).to eq(described_class.name)
+    end
+
+    it 'logs initialization' do
+      plugin
+      expect(@log_output.readline).to eq("  DEBUG  Usmu::S3 : Initializing usmu-s3 v#{Usmu::S3::VERSION}\n")
+    end
+  end
+
+  context '#commands' do
+    let(:ui) { OpenStruct.new }
+
+    it 'logs when commands are accessed' do
+      plugin.commands(ui, commander)
+      # Discard the line from initialization
+      @log_output.readline
+      expect(@log_output.readline).to eq("  DEBUG  Usmu::S3 : Adding commands from usmu-s3.\n")
+    end
+
+    it 'preserves the UI for later usage' do
+      plugin.commands(ui, commander)
+      expect(plugin.send :ui).to eq(ui)
+    end
+
+    it 'creates an "s3 deploy" command' do
+      plugin.commands(ui, commander)
+      expect(commander.get_command(:'s3 deploy')[:syntax]).to eq('usmu s3 deploy')
+      expect(commander.get_command(:'s3 deploy')[:description]).to eq('Deploys your website to S3')
+      expect(commander.get_command(:'s3 deploy')[:action].arity).to eq(-1)
+    end
+  end
+
+  context '#command_deploy' do
+    let(:empty_configuration) { Usmu::Configuration.from_hash({}) }
+    let(:configuration) {
+      Usmu::Configuration.from_hash(
+          {
+              'plugin' => {
+                  's3' => {
+                      'bucket' => 'test',
+                  },
+              },
+          }
+      )
+    }
+    let(:s3_configuration) { OpenStruct.new }
+    let(:ui) { OpenStruct.new configuration: configuration }
+    let(:empty_ui) { OpenStruct.new configuration: empty_configuration }
+    let(:differ) { OpenStruct.new get_diffs: diffs }
+    let(:diffs) { OpenStruct.new }
+    let(:uploader) { Usmu::UploaderMock.new }
+    let(:remote_files) { OpenStruct.new }
+
+    it 'raises an error when arguments are specified' do
+      expect { plugin.command_deploy(['foo']) }.to raise_error('This command does not take arguments.')
+    end
+
+    it 'raises an error when invalid options are specified' do
+      expect { plugin.command_deploy([], []) }.to raise_error('Invalid options, must be a Hash.')
+    end
+
+    it 'gets a DirectoryDiff and passes that to an Uploader' do
+      plugin.send :ui=, ui
+      expect(Usmu::S3::RemoteFiles).to receive(:new).with(s3_configuration).and_return(remote_files)
+      expect(Usmu::Deployment::DirectoryDiff).to receive(:new).with(configuration, remote_files).and_return(differ)
+      expect(Usmu::S3::Uploader).to receive(:new).with(configuration, s3_configuration).and_return(uploader)
+      expect(Usmu::S3::S3Configuration).to receive(:new).with({'bucket' => 'test'}).and_return(s3_configuration)
+      plugin.command_deploy
+      expect(uploader.diffs).to eq(diffs)
+    end
+
+    it 'it uses default values if not configured' do
+      plugin.send :ui=, empty_ui
+      expect(Usmu::S3::RemoteFiles).to receive(:new).with(s3_configuration).and_return(remote_files)
+      expect(Usmu::Deployment::DirectoryDiff).to receive(:new).with(empty_configuration, remote_files).and_return(differ)
+      expect(Usmu::S3::Uploader).to receive(:new).with(empty_configuration, s3_configuration).and_return(uploader)
+      expect(Usmu::S3::S3Configuration).to receive(:new).with({}).and_return(s3_configuration)
+      plugin.command_deploy
+    end
+
+    it 'logs progress' do
+      plugin.send :ui=, ui
+      expect(Usmu::S3::RemoteFiles).to receive(:new).with(s3_configuration).and_return(remote_files)
+      expect(Usmu::Deployment::DirectoryDiff).to receive(:new).with(configuration, remote_files).and_return(differ)
+      expect(Usmu::S3::Uploader).to receive(:new).with(configuration, s3_configuration).and_return(uploader)
+      expect(Usmu::S3::S3Configuration).to receive(:new).with({'bucket' => 'test'}).and_return(s3_configuration)
+      plugin.command_deploy
+
+      # Discard the line from initialization
+      @log_output.readline
+
+      expect(@log_output.readline).to eq("   INFO  Usmu::S3 : Gathering information...\n")
+      expect(@log_output.readline).to eq("   INFO  Usmu::S3 : Uploading files.\n")
+      expect(@log_output.readline).to eq("   INFO  Usmu::S3 : Website updated successfully.\n")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,112 @@
+begin
+  require 'codeclimate-test-reporter'
+  CodeClimate::TestReporter.start
+rescue LoadError
+end
+
+require 'logging'
+require 'rspec/logging_helper'
+require 'timeout'
+
+Logging.init :debug, :info, :success, :warn, :error, :fatal
+
+# 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 this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = false
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # Set a timeout on individual tests
+  config.around(:each) do |example|
+    Timeout.timeout(5, &example)
+  end
+
+  # Configure RSpec to capture log messages for tests.
+  include RSpec::LoggingHelper
+  config.capture_log_messages
+end
+
+# Load turnip step definitions
+Dir['spec/**/*_steps.rb'].each {|f| require f[10..f.length] }
+
+# Allow loading of mocks
+$LOAD_PATH.unshift(File.realpath('./spec/mock')) if File.exist? 'spec/mock'

data/usmu-s3.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'usmu/s3/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'usmu-s3'
+  spec.version       = Usmu::S3::VERSION
+  spec.authors       = ['Matthew Scharley']
+  spec.email         = ['matt.scharley@gmail.com']
+  spec.summary       = %q{S3 publishing plugin for Usmu.}
+  spec.homepage      = 'https://github.com/usmu/usmu-s3'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^spec/})
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = Gem::Requirement.new('>= 1.9.3')
+
+  spec.add_dependency 'usmu', '~> 0.3', '>= 0.3.4'
+  spec.add_dependency 'logging', '~> 1.8'
+  spec.add_dependency 'aws-sdk', '~> 2.0.pre', '>= 2.0.17'
+  #spec.add_dependency 'ruby-filemagic', '~> 0.6'
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.1'
+  spec.add_development_dependency 'yard', '~> 0.8'
+  spec.add_development_dependency 'guard', '~> 2.8'
+  spec.add_development_dependency 'guard-rspec', '~> 4.3'
+  spec.add_development_dependency 'libnotify', '~> 0.9'
+  spec.add_development_dependency 'turnip', '~> 1.2'
+  spec.add_development_dependency 'timeout', '~> 0.0'
+end