stratocumulus 0.0.5 → 0.0.6

data/spec/unit/retention_spec.rb

@@ -1,5 +1,5 @@
 # encoding: UTF-8
-require 'spec_helper'
+require "spec_helper"
 
 describe Stratocumulus::Retention do
   subject { described_class.new(schedule) }
@@ -8,7 +8,7 @@ describe Stratocumulus::Retention do
     {
       1 => 30,
       7 => 8,
-      30 => 12
+      30 => 12,
     }
   end
 
@@ -24,44 +24,43 @@ describe Stratocumulus::Retention do
     (1..12).map { |i| i * 30 }
   end
 
-  let(:key) { 'testdb/testdbTIMESTAMP.sql.gz' }
+  let(:key) { "testdb/testdbTIMESTAMP.sql.gz" }
 
-  let(:expires_in_days) { subject.rule(key)['Days'] }
+  let(:expires_in_days) { subject.rule(key)["Days"] }
 
-  describe '#rule' do
-
-    it 'returns a rule with the key and an expiry' do
+  describe "#rule" do
+    it "returns a rule with the key and an expiry" do
       stub_yday(30)
       expect(subject.rule(key)).to eq(
-        'Days' => 360,
-        'Enabled' => true,
-        'ID' => key,
-        'Prefix' => key
+        "Days" => 360,
+        "Enabled" => true,
+        "ID" => key,
+        "Prefix" => key,
       )
     end
 
-    it 'it keeps a daily backup for a month' do
+    it "it keeps a daily backup for a month" do
       keep_for_a_month.each do |day|
         stub_yday(day)
         expect(expires_in_days).to eq 30
       end
     end
 
-    it 'keeps a weekly backup for 8 weeks' do
+    it "keeps a weekly backup for 8 weeks" do
       keep_for_two_months.each do |day|
         stub_yday(day)
         expect(expires_in_days).to eq 56
       end
     end
 
-    it 'keeps a monthly backup for 12 months' do
+    it "keeps a monthly backup for 12 months" do
       keep_for_a_year.each do |day|
         stub_yday(day)
         expect(expires_in_days).to eq 360
       end
     end
 
-    context 'a non daily schedule' do
+    context "a non daily schedule" do
       let(:schedule) do
         { 14 => 2 }
       end
@@ -74,7 +73,7 @@ describe Stratocumulus::Retention do
         (1..365).to_a - days_to_keep
       end
 
-      it 'keeps fortightly backups for 2 fortnights' do
+      it "keeps fortightly backups for 2 fortnights" do
         days_to_keep.each do |day|
           stub_yday(day)
           expect(subject.upload_today?).to be_truthy
@@ -82,7 +81,7 @@ describe Stratocumulus::Retention do
         end
       end
 
-      it 'keeps nothing on the other days' do
+      it "keeps nothing on the other days" do
         days_not_to_keep.each do |day|
           stub_yday(day)
           expect(subject.upload_today?).to be_falsy
@@ -90,14 +89,14 @@ describe Stratocumulus::Retention do
       end
     end
 
-    context 'with no schedule' do
+    context "with no schedule" do
       let(:schedule) { nil }
 
-      it 'runs the backup' do
+      it "runs the backup" do
         expect(subject.upload_today?).to eq true
       end
 
-      it 'keeps the backup forever' do
+      it "keeps the backup forever" do
         expect(subject.rule(key)).to be_nil
       end
     end

data/spec/unit/runner_spec.rb

@@ -1,8 +1,8 @@
 # encoding: UTF-8
-require 'spec_helper'
+require "spec_helper"
 
 describe Stratocumulus::Runner do
-  subject { described_class.new('spec/support/test_config_file.yml') }
+  subject { described_class.new("spec/support/test_config_file.yml") }
   let(:storage) { double(upload: true) }
   let(:database) { double }
   let(:database2) { double }
@@ -15,41 +15,41 @@ describe Stratocumulus::Runner do
     subject.run
   end
 
-  it 'passes the correct config to Storage' do
+  it "passes the correct config to Storage" do
     expect(Stratocumulus::Storage).to receive(:new).twice.with(
-      'access_key_id' => 'I_AM_THE_KEY_ID',
-      'secret_access_key' => 'IamTHESekret',
-      'bucket' => 'stratocumulus-test',
-      'region' => 'eu-west1',
-      'retention' => { 1 => 30, 30 => 12 }
+      "access_key_id" => "I_AM_THE_KEY_ID",
+      "secret_access_key" => "IamTHESekret",
+      "bucket" => "stratocumulus-test",
+      "region" => "eu-west1",
+      "retention" => { 1 => 30, 30 => 12 },
     ).and_return(storage)
   end
 
-  it 'passes each database config to instances of Database' do
+  it "passes each database config to instances of Database" do
     expect(Stratocumulus::Database).to receive(:new).once.with(
-      'type' => 'mysql',
-      'name' => 'stratocumulus_test',
-      'storage' => 's3',
-      'username' => 'root',
-      'password' => 'sekret',
-      'host' => 'db1.example.com',
-      'port' => 3307
+      "type" => "mysql",
+      "name" => "stratocumulus_test",
+      "storage" => "s3",
+      "username" => "root",
+      "password" => "sekret",
+      "host" => "db1.example.com",
+      "port" => 3307,
     )
 
     expect(Stratocumulus::Database).to receive(:new).once.with(
-      'type' => 'mysql',
-      'name' => 'stratocumulus_test_2',
-      'storage' => 's3'
+      "type" => "mysql",
+      "name" => "stratocumulus_test_2",
+      "storage" => "s3",
     )
   end
 
-  it 'uploads each database to storage' do
+  it "uploads each database to storage" do
     allow(Stratocumulus::Database).to receive(:new).once.with(
-      hash_including('name' => 'stratocumulus_test')
+      hash_including("name" => "stratocumulus_test"),
     ).and_return(database)
 
     allow(Stratocumulus::Database).to receive(:new).once.with(
-      hash_including('name' => 'stratocumulus_test_2')
+      hash_including("name" => "stratocumulus_test_2"),
     ).and_return(database2)
 
     expect(storage).to receive(:upload).once.with(database)

data/spec/unit/storage_spec.rb

@@ -1,13 +1,13 @@
 # encoding: UTF-8
-require 'spec_helper'
+require "spec_helper"
 
 describe Stratocumulus::Storage do
   let(:base_config) do
     {
-      'access_key_id' => 'IM_A_ID',
-      'secret_access_key' => 'IM_A_SEKRET_KEY',
-      'region' =>  'eu-west-1',
-      'bucket' =>  'stratocumulus-test'
+      "access_key_id" => "IM_A_ID",
+      "secret_access_key" => "IM_A_SEKRET_KEY",
+      "region" =>  "eu-west-1",
+      "bucket" =>  "stratocumulus-test",
     }
   end
 
@@ -15,7 +15,7 @@ describe Stratocumulus::Storage do
 
   subject { described_class.new(config) }
 
-  describe '#upload' do
+  describe "#upload" do
     let(:connection) { double(:fog_conn, directories: directories) }
     let(:directories) { double(:fog_dirs, get: double(files: files)) }
     let(:files) { double(:fog_files, create: file) }
@@ -24,9 +24,9 @@ describe Stratocumulus::Storage do
     let(:database) do
       double(
         :database,
-        filename: 'foo.sql.gz',
+        filename: "foo.sql.gz",
         dump: :database_dump,
-        success?: true
+        success?: true,
       )
     end
 
@@ -44,37 +44,56 @@ describe Stratocumulus::Storage do
       stderr
     end
 
-    it 'uploads the dump to s3' do
-      expect(files).to receive(:create).with(
-        key: 'foo.sql.gz',
-        body: :database_dump,
-        multipart_chunk_size: 104_857_600,
-        public: false
-      )
+    context "without specified folder" do
+      it "uploads the dump to s3" do
+        expect(files).to receive(:create).with(
+          key: "foo.sql.gz",
+          body: :database_dump,
+          multipart_chunk_size: 104_857_600,
+          public: false,
+        )
+      end
+    end
+
+    context "with specified folder" do
+      let(:config) do
+        base_config.merge(
+          "folder" => "folder",
+        )
+      end
+
+      it "uploads the dump to s3 in the right folder" do
+        expect(files).to receive(:create).with(
+          key: "folder/foo.sql.gz",
+          body: :database_dump,
+          multipart_chunk_size: 104_857_600,
+          public: false,
+        )
+      end
     end
 
-    it 'uploads to the correct s3 bucket' do
-      expect(directories).to receive(:get).with('stratocumulus-test')
+    it "uploads to the correct s3 bucket" do
+      expect(directories).to receive(:get).with("stratocumulus-test")
     end
 
-    describe 'the fog connection' do
-      it 'is setup corectly' do
+    describe "the fog connection" do
+      it "is setup corectly" do
         expect(Fog::Storage).to receive(:new)
-        .with(
-          provider: 'AWS',
-          aws_access_key_id: 'IM_A_ID',
-          aws_secret_access_key: 'IM_A_SEKRET_KEY',
-          region: 'eu-west-1'
-        ).and_return(connection)
+          .with(
+            provider: "AWS",
+            aws_access_key_id: "IM_A_ID",
+            aws_secret_access_key: "IM_A_SEKRET_KEY",
+            region: "eu-west-1",
+          ).and_return(connection)
       end
     end
 
-    context 'with a schedule' do
+    context "with a schedule" do
       let(:config) do
         base_config.merge(
-          'retention' => {
-            1 => 30
-          }
+          "retention" => {
+            1 => 30,
+          },
         )
       end
 
@@ -84,36 +103,36 @@ describe Stratocumulus::Storage do
 
       let(:service) { double(:fog_service) }
 
-      context 'no rules set on the bucket yet' do
+      context "no rules set on the bucket yet" do
         before do
           allow(service).to receive(:get_bucket_lifecycle)
-            .with('stratocumulus-test')
-            .and_raise(Excon::Errors::NotFound, '404 No rules set yet')
+            .with("stratocumulus-test")
+            .and_raise(Excon::Errors::NotFound, "404 No rules set yet")
         end
 
-        it 'puts a rule for the uploaded file' do
+        it "puts a rule for the uploaded file" do
           expect(service).to receive(:put_bucket_lifecycle)
             .with(
-              'stratocumulus-test',
-              'Rules' => [
+              "stratocumulus-test",
+              "Rules" => [
                 {
-                  'ID' => 'foo.sql.gz',
-                  'Prefix' => 'foo.sql.gz',
-                  'Enabled' => true,
-                  'Days' => 30
-                }
-              ]
+                  "ID" => "foo.sql.gz",
+                  "Prefix" => "foo.sql.gz",
+                  "Enabled" => true,
+                  "Days" => 30,
+                },
+              ],
             )
         end
       end
 
-      context 'when the database is not sucessfull' do
+      context "when the database is not sucessfull" do
         let(:database) do
           double(
             :database,
-            filename: 'foo.sql.gz',
+            filename: "foo.sql.gz",
             dump: :database_dump,
-            success?: false
+            success?: false,
           )
         end
 
@@ -121,73 +140,73 @@ describe Stratocumulus::Storage do
           allow(file).to receive(:destroy)
         end
 
-        it 'destroys the failing dump' do
+        it "destroys the failing dump" do
           expect(file).to receive(:destroy)
         end
 
-        it 'does not create a expiry rule' do
+        it "does not create a expiry rule" do
           expect(service).to_not receive(:put_bucket_lifecycle)
         end
 
-        it 'logs the error to stderr' do
+        it "logs the error to stderr" do
           expect(stderr).to include(
-            'ERROR -- : there was an error generating foo.sql.gz'
+            "ERROR -- : there was an error generating foo.sql.gz",
           )
         end
       end
 
-      context 'rules allready set on the bucket' do
+      context "rules allready set on the bucket" do
         let(:files) { [existing_file] }
-        let(:existing_file) { double(:fog_file, key: 'bar.sql.gz') }
+        let(:existing_file) { double(:fog_file, key: "bar.sql.gz") }
         let(:existing_rules) do
           [
             {
-              'ID' => 'bar.sql.gz',
-              'Prefix' => 'bar.sql.gz',
-              'Enabled' => true,
-              'Days' => 30
+              "ID" => "bar.sql.gz",
+              "Prefix" => "bar.sql.gz",
+              "Enabled" => true,
+              "Days" => 30,
             },
             {
-              'ID' => 'baz.sql.gz',
-              'Prefix' => 'baz.sql.gz',
-              'Enabled' => true,
-              'Days' => 30
-            }
+              "ID" => "baz.sql.gz",
+              "Prefix" => "baz.sql.gz",
+              "Enabled" => true,
+              "Days" => 30,
+            },
           ]
         end
 
         before do
           allow(service).to receive(:get_bucket_lifecycle)
-            .with('stratocumulus-test')
+            .with("stratocumulus-test")
             .and_return(
               double(
                 data: {
                   body: {
-                    'Rules' => existing_rules
-                  }
-                }
-              )
+                    "Rules" => existing_rules,
+                  },
+                },
+              ),
             )
           allow(files).to receive(:create).and_return(:true)
         end
 
-        it 'adds the rule to the rules for existing files' do
+        it "adds the rule to the rules for existing files" do
           expect(service).to receive(:put_bucket_lifecycle).with(
-            'stratocumulus-test',
-            'Rules' => [
+            "stratocumulus-test",
+            "Rules" => [
               {
-                'ID' => 'bar.sql.gz',
-                'Prefix' => 'bar.sql.gz',
-                'Enabled' => true,
-                'Days' => 30
+                "ID" => "bar.sql.gz",
+                "Prefix" => "bar.sql.gz",
+                "Enabled" => true,
+                "Days" => 30,
               },
               {
-                'ID' => 'foo.sql.gz',
-                'Prefix' => 'foo.sql.gz',
-                'Enabled' => true,
-                'Days' => 30
-              }
-            ]
+                "ID" => "foo.sql.gz",
+                "Prefix" => "foo.sql.gz",
+                "Enabled" => true,
+                "Days" => 30,
+              },
+            ],
           )
         end
       end