s3_website_monadic 0.0.15 → 0.0.16

data/spec/lib/cloudfront/invalidator_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-describe S3Website::Cloudfront::Invalidator do
-  let(:config) {{
-    's3_id' => 'aws id',
-    's3_secret' => 'aws secret',
-    'cloudfront_distribution_id' => 'EFXX'
-  }}
-
-  describe 'default behaviour' do
-    it 'invalidates the root resource' do
-      invalidator = create_simple_cloudfront_invalidator(config)
-      invalidator.
-        should_receive(:invalidate).
-        with(['index.html', '']).
-        and_return(:text_report => 'report txt')
-
-      S3Website::Cloudfront::Invalidator.invalidate(config, ['index.html'])
-    end
-  end
-
-  context 'option cloudfront_invalidate_root = true' do
-    let(:config_with_root_invalidation) {
-      config.merge( {
-        'cloudfront_invalidate_root' => true
-      })
-    }
-
-    it 'invalidates all root resources' do
-      invalidator = create_simple_cloudfront_invalidator(config_with_root_invalidation)
-      invalidator.
-        should_receive(:invalidate).
-        with(['article/', '']).
-        and_return(:text_report => 'report txt')
-
-      S3Website::Cloudfront::Invalidator.invalidate(config_with_root_invalidation, ['article/index.html'])
-    end
-  end
-
-  context 'the file name contains special characters' do
-    it 'encodes the file paths according to rfc1738' do
-      invalidator = create_simple_cloudfront_invalidator config
-      invalidator.
-        should_receive(:invalidate).
-        with(['article/arnold%27s%20file.html', '']).
-        and_return(:text_report => 'report txt')
-
-      S3Website::Cloudfront::Invalidator.invalidate(config, ["article/arnold's file.html"])
-    end
-  end
-
-  def create_simple_cloudfront_invalidator(config)
-    invalidator = double('invalidator')
-    SimpleCloudfrontInvalidator::CloudfrontClient.
-      should_receive(:new).
-      with(config['s3_id'], config['s3_secret'], config['cloudfront_distribution_id']).
-      and_return(invalidator)
-    invalidator
-  end
-end

data/spec/lib/config_loader_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe S3Website::ConfigLoader do
-  it 'supports eRuby syntax in s3_website.yml' do
-    config = S3Website::ConfigLoader.load_configuration('spec/sample_files/hyde_site/')
-    config['s3_id'].should eq('hello')
-    config['s3_secret'].should eq('world')
-    config['s3_bucket'].should eq('galaxy')
-  end
-
-  it 'does not define default endpoint' do
-    config = S3Website::ConfigLoader.load_configuration('spec/sample_files/hyde_site/')
-    config['s3_endpoint'].should be_nil
-  end
-
-  it 'reads the S3 endpoint setting from s3_website.yml' do
-    config = S3Website::ConfigLoader.load_configuration('spec/sample_files/tokyo_site')
-    config['s3_endpoint'].should eq('ap-northeast-1')
-  end
-end

data/spec/lib/endpoint_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-require 'pp'
-
-describe S3Website::Endpoint do
-
-  it 'uses the DEFAULT_LOCATION_CONSTRAINT constant to set the default location constraint' do
-    endpoint = S3Website::Endpoint.new
-    endpoint.location_constraint.should eq(S3Website::Endpoint::DEFAULT_LOCATION_CONSTRAINT)
-  end
-
-  it 'uses the "us-east-1" as the default location' do
-    S3Website::Endpoint::DEFAULT_LOCATION_CONSTRAINT.should eq('us-east-1')
-  end
-
-  it 'takes a valid location constraint as a constructor parameter' do
-    endpoint = S3Website::Endpoint.new('EU')
-    endpoint.location_constraint.should eq('EU')
-  end
-
-  it 'takes eu-west-1 as an alias for EU' do
-    endpoint = S3Website::Endpoint.new('eu-west-1')
-    endpoint.location_constraint.should eq('eu-west-1')
-    S3Website::Endpoint.new.location_constraints['EU'].should eq(S3Website::Endpoint.new.location_constraints['eu-west-1'])
-  end
-
-  it 'fails if the location constraint is invalid' do
-    expect {
-      S3Website::Endpoint.new('andromeda')
-    }.to raise_error
-  end
-end

data/spec/lib/error_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-describe 'error reporting' do
-  it 'prints the class name of the error' do
-    S3Website::error_report(SocketError.new('network is down')).should include(
-      'SocketError'
-    )
-  end
-
-  it 'prints the message of the error' do
-    S3Website::error_report(SocketError.new('network is down')).should eq(
-      'network is down (SocketError)'
-    )
-  end
-
-  it "only prints the message if the error is an #{S3Website::S3WebsiteError}" do
-    S3Website::error_report(S3Website::NoWebsiteDirectoryFound.new()).should eq(
-      "I can't find any website. Are you in the right directory?"
-    )
-  end
-end

data/spec/lib/keyboard_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-
-describe S3Website::Keyboard do
-  describe '.keep_or_delete' do
-    let(:s3_object_keys) { ['a', 'b', 'c'] }
-    let(:standard_input) { stub('std_in') }
-
-    it 'can delete only the first item' do
-      standard_input.stub(:gets).and_return("d", "K")
-      deleted_keys = call_keyboard(s3_object_keys, standard_input)
-      deleted_keys.should eq(['a'])
-    end
-
-    it 'can delete only the second item' do
-      standard_input.stub(:gets).and_return("k", "d", "k")
-      deleted_keys = call_keyboard(s3_object_keys, standard_input)
-      deleted_keys.should eq(['b'])
-    end
-
-    it 'can delete all but the first item' do
-      standard_input.stub(:gets).and_return("k", "D")
-      deleted_keys = call_keyboard(s3_object_keys, standard_input)
-      deleted_keys.should eq(['b', 'c'])
-    end
-
-    it 'can delete all s3 objects' do
-      standard_input.stub(:gets).and_return("D")
-      deleted_keys = call_keyboard(s3_object_keys, standard_input)
-      deleted_keys.should eq(['a', 'b', 'c'])
-    end
-
-    it 'can keep one s3 object' do
-      standard_input.stub(:gets).and_return("k", "d", "d")
-      deleted_keys = call_keyboard(s3_object_keys, standard_input)
-      deleted_keys.should eq(['b', 'c'])
-    end
-
-    it 'can keep all s3 objects' do
-      standard_input.stub(:gets).and_return("k", "k", "k")
-      deleted_keys = call_keyboard(s3_object_keys, standard_input)
-      deleted_keys.should eq([])
-    end
-
-    it 'can keep all s3 objects' do
-      standard_input.stub(:gets).and_return("K")
-      deleted_keys = call_keyboard(s3_object_keys, standard_input)
-      deleted_keys.should eq([])
-    end
-
-    def call_keyboard(s3_object_keys, standard_input)
-      deleted_keys = []
-      S3Website::Keyboard.if_user_confirms_delete(
-        s3_object_keys,
-        config = {},
-        standard_input
-      ) { |key|
-        deleted_keys << key
-      }
-      deleted_keys
-    end
-  end
-end

data/spec/lib/parallelism_spec.rb

@@ -1,81 +0,0 @@
-require 'spec_helper'
-
-describe S3Website::Parallelism do
-  context 'user has disabled parallelism' do
-    let(:config) {
-      {}
-    }
-
-    before(:all) {
-      @original_disable_state = ENV['disable_parallel_processing']
-      ENV['disable_parallel_processing'] = 'true'
-    }
-
-    after(:all) {
-      ENV['disable_parallel_processing'] = @original_disable_state
-    }
-
-    it 'runs things sequentially' do
-      ints = (0..100).to_a
-      after_processing = []
-      S3Website::Parallelism.each_in_parallel_or_sequentially(ints, config) { |int|
-        after_processing << int
-      }
-      ints.should eq(after_processing)
-    end
-  end
-
-  context 'user has not disabled parallelism' do
-    let(:config) {
-      {}
-    }
-
-    before(:all) {
-      @original_disable_state = ENV['disable_parallel_processing']
-      ENV.delete 'disable_parallel_processing'
-    }
-
-    after(:all) {
-      ENV['disable_parallel_processing'] = @original_disable_state if @original_disable_state
-    }
-
-    it 'runs things in parallel' do
-      ints = (0..100).to_a
-      after_processing = []
-      S3Website::Parallelism.each_in_parallel_or_sequentially(ints, config) { |int|
-        after_processing << int
-      }
-      ints.should_not eq(after_processing) # Parallel processing introduces non-determinism
-    end
-  end
-
-  context 'limiting parallelism' do
-    shared_examples 'parallel processing' do |config|
-      let(:concurrency_level) {
-        config['concurrency_level'] || S3Website::Parallelism::DEFAULT_CONCURRENCY_LEVEL
-      }
-
-      before(:each) {
-        ints = (0..199).to_a
-        @after_processing = []
-        S3Website::Parallelism.each_in_parallel_or_sequentially(ints, config) { |int|
-          @after_processing << int
-        }
-      }
-
-      it "does at most <concurrency_level> operations in parallel" do
-        @after_processing.slice(0, concurrency_level).all? do |int|
-          int <= concurrency_level
-        end.should be true
-        @after_processing.slice(100, concurrency_level).all? do |int|
-          int >= 100 and int <= 100 + concurrency_level
-        end.should be true
-      end
-    end
-
-
-    include_examples 'parallel processing', config = {}
-
-    include_examples 'parallel processing', config = { 'concurrency_level' => 100 }
-  end
-end

data/spec/lib/paths_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe S3Website::Paths do
-  it 'recognises Jekyll and Nanoc site paths' do
-    S3Website::Paths.site_paths.should eq(['public/output', '_site'])
-  end
-end

data/spec/lib/retry_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe S3Website::Retry do
-  describe ".run_with_retry" do
-    it "retry the operation 4 times" do
-      retries = 0
-      begin
-        S3Website::Retry.run_with_retry(0.001) {
-          retries += 1
-          raise Exception
-        }
-      rescue
-      end
-      retries.should be(4)
-    end
-
-    it "throws an error if all retries fail" do
-      expect {
-        S3Website::Retry.run_with_retry(0.001) {
-          raise Exception
-        }
-      }.to raise_error(S3Website::RetryAttemptsExhaustedError)
-    end
-
-    it "re-runs the block if the block throws an error" do
-      retries = 0
-      S3Website::Retry.run_with_retry(0.001) {
-        retries += 1
-        raise Exception if retries < 2
-      }
-      retries.should be(2)
-    end
-  end
-end

data/spec/lib/upload_spec.rb

@@ -1,303 +0,0 @@
-require 'spec_helper'
-
-describe S3Website::Upload do
-  describe 'uploading blacklisted files' do
-    let(:blacklisted_files) {
-      [ 's3_website.yml' ]
-    }
-    it 'should fail if the upload file is s3_website.yml' do
-      blacklisted_files.each do |blacklisted_file|
-        expect {
-          S3Website::Upload.new blacklisted_file, mock(), {}, mock()
-        }.to raise_error "May not upload #{blacklisted_file}, because it's blacklisted"
-      end
-    end
-
-    it 'should fail to upload configured blacklisted files' do
-      config = { 'exclude_from_upload' => 'vendor' }
-
-      expect {
-        S3Website::Upload.new "vendor/jquery/development.js", mock(), config, mock()
-      }.to raise_error "May not upload vendor/jquery/development.js, because it's blacklisted"
-    end
-
-    context 'the uploaded file matches a value in the exclude_from_upload setting' do
-      it 'should fail to upload any configured blacklisted files' do
-        config = { 'exclude_from_upload' => ['vendor', 'tests'] }
-
-        expect {
-          S3Website::Upload.new "vendor/jquery/development.js", mock(), config, mock()
-        }.to raise_error "May not upload vendor/jquery/development.js, because it's blacklisted"
-
-        expect {
-          S3Website::Upload.new "tests/spec_helper.js", mock(), config, mock()
-        }.to raise_error "May not upload tests/spec_helper.js, because it's blacklisted"
-      end
-
-      it 'supports regexes in the exclude_from_upload setting' do
-        config = { 'exclude_from_upload' => 'test.*' }
-
-        expect {
-          S3Website::Upload.new "tests/spec_helper.js", mock(), config, mock()
-        }.to raise_error "May not upload tests/spec_helper.js, because it's blacklisted"
-      end
-    end
-  end
-
-  describe 'reduced redundancy setting' do
-    let(:config) {
-      { 's3_reduced_redundancy' => true }
-    }
-
-    it 'allows storing a file under the Reduced Redundancy Storage' do
-      should_upload(
-        file = 'index.html',
-        site = 'features/support/test_site_dirs/my.blog.com/_site', config) { |s3_object|
-        s3_object.should_receive(:write).with(
-          anything(),
-          include(:reduced_redundancy => true)
-        )
-      }
-    end
-  end
-
-  describe 'content type resolving' do
-    it 'adds the content type of the uploaded CSS file into the S3 object' do
-      should_upload(
-        file = 'css/styles.css',
-        site = 'features/support/test_site_dirs/my.blog.com/_site') { |s3_object|
-        s3_object.should_receive(:write).with(
-          anything(),
-          include(:content_type => 'text/css; charset=utf-8')
-        )
-      }
-    end
-
-    it 'adds the content type of the uploaded HTML file into the S3 object' do
-      should_upload(
-        file = 'index.html',
-        site = 'features/support/test_site_dirs/my.blog.com/_site') { |s3_object|
-        s3_object.should_receive(:write).with(
-          anything(),
-          include(:content_type => 'text/html; charset=utf-8')
-        )
-      }
-    end
-
-    describe 'encoding of text documents' do
-      it 'should mark all text documents as utf-8' do
-        should_upload(
-          file = 'file.txt',
-          site = 'features/support/test_site_dirs/site-with-text-doc.com/_site') { |s3_object|
-          s3_object.should_receive(:write).with(
-            anything(),
-            include(:content_type => 'text/plain; charset=utf-8')
-          )
-        }
-      end
-    end
-
-    context 'the user specifies a mime-type for extensionless files' do
-      let(:config) {{
-        'extensionless_mime_type' => "text/html"
-      }}
-
-      it 'adds the content type of the uploaded extensionless file into the S3 object' do
-        should_upload(
-          file = 'index',
-          site = 'features/support/test_site_dirs/my.blog-with-clean-urls.com/_site',
-          config) { |s3_object|
-          s3_object.should_receive(:write).with(
-            anything(),
-            include(:content_type => 'text/html; charset=utf-8')
-          )
-        }
-      end
-    end
-  end  
-
-  describe 'gzip compression' do
-    let(:config){
-      {
-        's3_reduced_redundancy' => false,
-        'gzip' => true
-      }
-    }
-
-    subject{ S3Website::Upload.new("index.html", mock(), config, 'features/support/test_site_dirs/my.blog.com/_site') }
-
-    describe '#gzip?' do
-      it 'should be false if the config does not specify gzip' do
-        config.delete 'gzip'
-        subject.should_not be_gzip
-      end
-
-      it 'should be false if gzip is true but does not match a default extension' do
-        subject.stub(:path).and_return("index.bork")
-        subject.should_not be_gzip
-      end
-
-      it 'should be true if gzip is true and file extension matches' do
-        subject.should be_gzip
-      end
-
-      it 'should be true if gzip is true and file extension matches custom supplied' do
-        config['gzip'] = %w(.bork)
-        subject.stub(:path).and_return('index.bork')
-        subject.should be_gzip
-      end
-    end       
-
-    describe '#gzipped_file' do
-      it 'should return a gzipped version of the file' do
-        gz = Zlib::GzipReader.new(subject.send(:gzipped_file))
-        gz.read.should == File.read('features/support/test_site_dirs/my.blog.com/_site/index.html')
-      end
-    end
-  end
-  
-  describe 'gzip zopfli' do
-    let(:config){
-      {
-        's3_reduced_redundancy' => false,
-        'gzip' => true,
-        'gzip_zopfli' => true
-      }
-    }
-
-    subject{ S3Website::Upload.new("index.html", mock(), config, 'features/support/test_site_dirs/my.blog.com/_site') }
-
-    # Zopfli should be compatible with the gzip format
-    describe '#gzipped_file' do
-      it 'should return a gzipped version of the file' do
-        gz = Zlib::GzipReader.new(subject.send(:gzipped_file))
-        gz.read.should == File.read('features/support/test_site_dirs/my.blog.com/_site/index.html')
-      end
-    end
-  end
-
-  describe 'cache control' do
-    let(:config){
-      {
-        's3_reduced_redundancy' => false,
-        'max_age' => 300
-      }
-    }
-
-    let(:subject) {
-      S3Website::Upload.new(
-        "index.html",
-        mock(),
-        config,
-        'features/support/test_site_dirs/my.blog.com/_site'
-      )
-    }
-
-    describe '#cache_control?' do
-      it 'should be false if max_age is missing' do
-        config.delete 'max_age'
-        subject.should_not be_cache_control
-      end
-
-      it 'should be true if max_age is present' do
-        subject.should be_cache_control
-      end
-
-      it 'should be true if max_age is a hash' do
-        config['max_age'] = {'*' => 300}
-        subject.should be_cache_control
-      end
-    end
-
-    context 'the user specifies max-age as zero' do
-      let(:config) {{
-        'max_age' => 0
-      }}
-
-      it 'includes the no-cache declaration in the cache-control metadata' do
-        subject.send(:upload_options)[:cache_control].should == 'no-cache, max-age=0'
-      end
-    end
-
-    describe '#max_age' do
-      it 'should be the universal value if one is set' do
-        subject.send(:max_age).should == 300
-      end
-
-      it 'should be the file-specific value if one is set' do
-        config['max_age'] = {'*index.html' => 500}
-        subject.send(:max_age).should == 500
-      end
-
-      it 'should be zero if no file-specific value hit' do
-        config['max_age'] = {'*.js' => 500}
-        subject.send(:max_age).should == 0
-      end
-
-      context 'overriding the more general setting with the more specific' do
-        let(:config){
-          {
-            's3_reduced_redundancy' => false,
-            'max_age' => {
-              '**'        => 150,
-              'assets/**' => 86400
-            }
-          }
-        }
-
-        it 'respects the most specific max-age selector' do
-          subject = S3Website::Upload.new(
-            'assets/picture.gif',
-            mock(),
-            config,
-            'features/support/test_site_dirs/index-and-assets.blog.fi/_site'
-          )
-          subject.send(:max_age).should == 86400
-        end
-
-        it 'respects the most specific max-age selector' do
-          subject = S3Website::Upload.new(
-            'index.html',
-            mock(),
-            config,
-            'features/support/test_site_dirs/index-and-assets.blog.fi/_site'
-          )
-          subject.send(:max_age).should == 150
-        end
-      end
-    end
-  end
-
-  def should_upload(file_to_upload, site_dir, config = {})
-    def create_verifying_s3_client(file_to_upload, &block)
-      def create_objects(file_to_upload, &block)
-        def create_html_s3_object(file_to_upload, &block)
-          s3_object = stub('s3_object')
-          yield s3_object
-          s3_object
-        end
-        objects = {}
-        objects[file_to_upload] = create_html_s3_object(file_to_upload, &block)
-        objects
-      end
-      def create_bucket(file_to_upload, &block)
-        bucket = stub('bucket')
-        bucket.stub(:objects => create_objects(file_to_upload, &block))
-        bucket
-      end
-      buckets = stub('buckets')
-      buckets.stub(:[] => create_bucket(file_to_upload, &block))
-      s3 = stub('s3')
-      s3.stub(:buckets => buckets)
-      s3
-    end
-
-    s3_client = create_verifying_s3_client(file_to_upload) do |s3_object|
-      yield s3_object
-    end
-    S3Website::Upload.new(file_to_upload,
-                          s3_client,
-                          config,
-                          site_dir).perform!
-  end
-end