xfrtuc 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 469868f9b222ed0b00e15c81978ae703d295d5a2
-  data.tar.gz: fe902d0b0a8bc2226fc1b8ed27e486cef6a4e002
+  metadata.gz: e5c7aa88517243fa936da71cd2baf17530348c95
+  data.tar.gz: 4b9e3d6c5a7948cdeeab336a5d1993500f31cc27
 SHA512:
-  metadata.gz: 3c6d75a45b7700a8d0555ca270dc3d19efbd3494388ff00583540dbb5bd5bdb38c225423490ff1a0ba97ee9f959e8d67b38d0d629632a3d7e597f75203e8c28d
-  data.tar.gz: a8e7211b3be5a37e6aaa9f35745c870a49a0fc6636c2e5b9327d9f1d897528d962f2af2151ba0731d7af22e232bc20e9b089973ffe45261b8e951aebeb87c2f3
+  metadata.gz: a54f5ecd5c7d4b3498641472f56255bc7126002710157a135092ea12ec1e84ce2d74d6e2777086ac426307eef79b8d5fda8175336ba886d6a3826f9a8a4037a2
+  data.tar.gz: 8fbb69a8ab07ac0bc57d689cf232c504fba2c9a99fa6eecf1be2985370b4f02330b9463d07a6ecc534f4cd48a188498933bbc2080197c5b66d93b47debae9d47

data/.ruby-version

@@ -0,0 +1 @@
+2.1.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in xfrtuc.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,40 @@
+PATH
+  remote: .
+  specs:
+    xfrtuc (0.0.2)
+      rest-client (~> 1.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    json (1.8.1)
+    mime-types (1.25.1)
+    rack (1.5.2)
+    rdoc (4.1.1)
+      json (~> 1.4)
+    rest-client (1.6.8)
+      mime-types (~> 1.16)
+      rdoc (>= 2.4.2)
+    rspec (3.0.0)
+      rspec-core (~> 3.0.0)
+      rspec-expectations (~> 3.0.0)
+      rspec-mocks (~> 3.0.0)
+    rspec-core (3.0.4)
+      rspec-support (~> 3.0.0)
+    rspec-expectations (3.0.4)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.0.0)
+    rspec-mocks (3.0.4)
+      rspec-support (~> 3.0.0)
+    rspec-support (3.0.4)
+    sham_rack (1.3.6)
+      rack
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rspec (~> 3.0)
+  sham_rack (~> 1.3)
+  xfrtuc!

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Maciek Sakrejda
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/xfrtuc.rb

@@ -0,0 +1,133 @@
+require 'json'
+require 'rest_client'
+
+module Xfrtuc
+  VERSION = "0.0.2"
+
+  class Client
+    attr_reader :base_url
+
+    def initialize(username, password, base_url: 'https://transferatu.heroku.com')
+      @base_url = base_url
+      @username = username
+      @password = password
+      @resource = RestClient::Resource.new(base_url,
+                                           user: username,
+                                           password: password,
+                                           headers: { content_type: 'application/json',
+                                                     accept: 'application/json' })
+    end
+
+    def transfer
+      @xfer_client ||= Xfrtuc::Transfer.new(self)
+    end
+
+    def schedule
+      @sched_client ||= Xfrtuc::Schedule.new(self)
+    end
+
+    def group(name=nil)
+      if name.nil?
+        @group_client ||= Xfrtuc::Group.new(self)
+      else
+        self.class.new(@username, @password,
+                       base_url: @base_url + "/groups/#{URI.encode(name)}")
+      end
+    end
+
+    def get(path, params={})
+      JSON.parse(@resource[path].get(params))
+    end
+
+    def post(path, data)
+      JSON.parse(@resource[path].post(JSON.generate(data)))
+    end
+
+    def delete(path)
+      JSON.parse(@resource[path].delete)
+    end
+  end
+
+  class ApiEndpoint
+    def initialize(client)
+      @client = client
+    end
+
+    protected
+
+    attr_reader :client
+  end
+
+  class Group < ApiEndpoint
+    def initialize(client); super; end
+
+    def info(name)
+      client.get("/groups/#{URI.encode(name)}")
+    end
+
+    def list
+      client.get("/groups")
+    end
+
+    def create(name, log_input_url=nil)
+      client.post("/groups", { name: name, log_input_url: log_input_url })
+    end
+
+    def delete(name)
+      client.delete("/groups/#{URI.encode(name)}")
+    end
+  end
+
+  class Transfer < ApiEndpoint
+    def initialize(client); super; end
+
+    def info(id)
+      client.get("/transfers/#{id}")
+    end
+
+    def list
+      client.get("/transfers")
+    end
+
+    def create(from_type:, from_url:, from_name: nil,
+               to_type:, to_url:, to_name: nil, opts: {})
+      client.post("/transfers",
+                  from_type: from_type,
+                  from_url: from_url,
+                  from_name: from_name,
+                  to_type: to_type,
+                  to_url: to_url,
+                  to_name: to_name)
+    end
+
+    def delete(id)
+      client.delete("/transfers/#{URI.encode(id)}")
+    end
+  end
+
+  class Schedule < ApiEndpoint
+    def initialize(client); super; end
+
+    def info(id)
+      client.get("/schedules/#{id}")
+    end
+
+    def list
+      client.get("/schedules")
+    end
+
+    def create(name:, callback_url:, hour:,
+               days: Date::DAYNAMES, timezone: 'UTC')
+      client.post("/schedules",
+                  name: name,
+                  callback_url: callback_url,
+                  hour: hour,
+                  days: days,
+                  timezone: timezone)
+    end
+
+    def delete(id)
+      client.delete("/schedules/#{URI.encode(id)}")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # 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'
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/xfrtuc_spec.rb

@@ -0,0 +1,542 @@
+require 'spec_helper'
+require 'sham_rack'
+
+module Xfrtuc
+  User = Struct.new(:name, :password)
+  class FakeTransferatu
+    attr_reader :groups
+
+    def headers
+      { content_type: 'application/json' }
+    end
+
+    def initialize(*users)
+      @groups = []
+      @transfers = {}
+      @schedules = {}
+      @users = users
+    end
+
+    def active_groups
+      @groups.reject { |g| g[:deleted] }
+    end
+
+    def find_transfer(group_name, &block)
+      @transfers[group_name].find(&block)
+    end
+
+    def last_transfer(group_name)
+      @transfers[group_name].last
+    end
+
+    def last_schedule(group_name)
+      @schedules[group_name].last
+    end
+
+    def add_group(name, log_url=nil)
+      existing_group = @groups.find { |g| g[:name] == name }
+      if existing_group
+        if existing_group[:deleted]
+          # undelete
+          existing_group.delete(:deleted)
+          [201, headers, [ existing_group.to_json ] ]
+        else
+          [409, headers, [ { id: :conflict, message: "group #{name} already exists" }.to_json ] ]
+        end
+      else
+        group = { name: name, log_input_url: log_url }
+        @groups << group
+        @transfers[name] = []
+        @schedules[name] = []
+        [201, headers, [ group.to_json ] ]
+      end
+    end
+
+    def delete_group(name)
+      target = @groups.find { |g| g[:name] == name }
+      if target && target[:deleted]
+        [410, headers, []]
+      elsif target.nil?
+        [404, headers, []]
+      else
+        target[:deleted] = true
+        [200, headers, [target.to_json]]
+      end
+    end
+
+    def list_groups
+      [200, headers, [@groups.to_json]]
+    end
+
+    def get_group(name)
+      [200, headers, [@groups.find { |g| g[:name] == name }.to_json]]
+    end
+
+    def list_transfers(group_name)
+      group = @groups.find { |g| g[:name] == group_name }
+      if group.nil?
+        [404, headers, []]
+      elsif group[:deleted]
+        [410, headers, []]
+      else
+        transfers = @transfers[group_name]
+        [200, headers, [transfers.to_json]]
+      end
+    end
+
+    def get_transfer(group_name, xfer_id, verbose: false)
+      group = @groups.find { |g| g[:name] == group_name }
+      if group.nil?
+        [404, headers, []]
+      elsif group[:deleted]
+        [409, headers, []]
+      else
+        transfer = @transfers[group_name].find { |xfer| xfer[:uuid] == xfer_id }
+        if verbose
+          result = transfer.dup
+          result[:logs] = []
+          transfer = result
+        end
+        [200, headers, [transfer.to_json]]
+      end
+    end
+
+    def add_transfer(group_name, transfer)
+      unless @transfers.has_key? group_name
+        return [404, headers, []]
+      end
+      xfer = { uuid: SecureRandom.uuid }
+      %w(from_type from_url from_name to_type to_url to_name).each do |key|
+        xfer[key.to_sym] = transfer[key]
+      end
+
+      @transfers[group_name] << xfer
+      [201, {}, [xfer.to_json]]
+    end
+
+    def delete_transfer(group_name, xfer_id)
+      unless @transfers.has_key? group_name
+        return [404, headers, []]
+      end
+      xfer = @transfers[group_name].find { |item| item[:uuid] == xfer_id }
+      if xfer.nil?
+        return [404, headers, []]
+      else
+        @transfers[group_name].delete xfer
+        return [200, headers, [ xfer.to_json ]]
+      end
+    end
+
+    def add_schedule(group_name, schedule)
+      unless @schedules.has_key? group_name
+        return [404, headers, []]
+      end
+      sched = { uuid: SecureRandom.uuid }
+      %w(name callback_url days hour timezone).each do |key|
+        sched[key.to_sym] = schedule[key]
+      end
+      @schedules[group_name] << sched
+      [201, {}, [sched.to_json]]
+    end
+
+    def delete_schedule(group_name, schedule_id)
+      unless @schedules.has_key? group_name
+        return [404, headers, []]
+      end
+      schedule = @schedules[group_name].find { |item| item[:uuid] == schedule_id }
+      if schedule.nil?
+        return [404, headers, []]
+      else
+        @schedules[group_name].delete schedule
+        return [200, headers, [ schedule.to_json ]]
+      end
+    end
+
+    def list_schedules(group_name)
+      group = @groups.find { |g| g[:name] == group_name }
+      if group.nil?
+        [404, headers, []]
+      elsif group[:deleted]
+        [410, headers, []]
+      else
+        schedules = @schedules[group_name]
+        [200, headers, [schedules.to_json]]
+      end
+    end
+
+    def get_schedule(group_name, sched_id)
+      group = @groups.find { |g| g[:name] == group_name }
+      if group.nil?
+        [404, headers, []]
+      elsif group[:deleted]
+        [410, headers, []]
+      else
+        sched = @schedules[group_name].find { |s| s[:uuid] == sched_id }
+        if sched.nil?
+          [404, headers, []]
+        else
+          [200, headers, [sched.to_json]]
+        end
+      end
+    end
+
+    def call(env)
+      unless verify_auth(env)
+        return [401, headers, ["Not authorized"]]
+      end
+      case path(env)
+      when %r{/groups/[^/]+/transfers} then
+        transfers_endpoint(env)
+      when %r{/groups/[^/]+/schedules} then
+        schedules_endpoint(env)
+      when %r{/groups} then
+        groups_endpoint(env)
+      else
+        [404, headers, []]
+      end
+    end
+
+    def transfers_endpoint(env)
+      path = path(env)
+      group_name, xfer_id = path.match(%r{\A/groups/(.*)/transfers(?:/(.*))?\z}) && [$1, $2]
+      verb = verb(env)
+      if verb == 'POST'
+        body = body(env)
+        xfer = JSON.parse(body)
+        unless xfer_id.nil?
+          [405, headers, []]
+        end
+        add_transfer(group_name, xfer)
+      elsif verb == 'DELETE'
+        unless group_name && xfer_id
+          return [404, headers, []]
+        end
+        delete_transfer(group_name, xfer_id)
+      elsif verb == 'GET'
+        if xfer_id.nil?
+          list_transfers(group_name)
+        else
+          get_transfer(group_name, xfer_id, verbose: params(env)['verbose'])
+        end
+      else
+        [405, headers, []]
+      end
+    end
+
+    def groups_endpoint(env)
+      path = path(env)
+      verb = verb(env)
+
+      group_name = path.match(%r{\A/groups/(.*)\z}) && $1
+
+      if verb == 'GET'
+        if group_name.nil?
+          list_groups
+        else
+          get_group(group_name)
+        end
+      elsif verb == 'POST'
+        body = body(env)
+        data = JSON.parse(body)
+        add_group(data["name"], data["log_input_url"])
+      elsif verb == 'DELETE'
+        name = path.match(%r{\A/groups/(.*)\z}) && $1
+        unless name
+          return [404, headers, []]
+        end
+        delete_group(name)
+      else
+        [405, headers, []]
+      end
+    end
+
+    def schedules_endpoint(env)
+      path = path(env)
+      group_name, sched_id = path.match(%r{\A/groups/(.*)/schedules(?:/(.*))?\z}) && [$1, $2]
+      verb = verb(env)
+      if verb == 'POST'
+        body = body(env)
+        sched = JSON.parse(body)
+        unless sched_id.nil?
+          [405, headers, []]
+        end
+        add_schedule(group_name, sched)
+      elsif verb == 'DELETE'
+        unless group_name && sched_id
+          return [404, headers, []]
+        end
+        delete_schedule(group_name, sched_id)
+      elsif verb == 'GET'
+        if sched_id.nil?
+          list_schedules(group_name)
+        else
+          get_schedule(group_name, sched_id)
+        end
+      else
+        [405, headers, []]
+      end
+    end
+
+    private
+    def verify_auth(env)
+      auth = Rack::Auth::Basic::Request.new(env)
+      if auth.provided? && auth.basic?
+        user, password = auth.credentials
+        @users.any? { |u| u.name == user && u.password == password }
+      end
+    end
+
+    def path(rack_env)
+      rack_env['PATH_INFO']
+    end
+
+    def verb(rack_env)
+      rack_env['REQUEST_METHOD']
+    end
+
+    def params(rack_env)
+      Rack::Utils.parse_nested_query rack_env['QUERY_STRING']
+    end
+
+    def body(rack_env)
+      raw_body = rack_env["rack.input"].read
+      rack_env["rack.input"].rewind
+      raw_body
+    end
+  end
+
+  describe Client do
+    let(:username) { 'reginald' }
+    let(:password) { 'hunter2' }
+    let(:client)   { Client.new(username, password) }
+
+    describe "#group" do
+      context "with an argument" do
+        let(:group_name) { 'foo' }
+
+        it "returns a new client rooted at that group's base URL" do
+          group_client = client.group(group_name)
+          expect(group_client).to be_instance_of(Client)
+          expect(group_client.base_url).to eq(client.base_url +
+                                              "/groups/#{URI.encode(group_name)}")
+        end
+      end
+
+      context "without an argument" do
+        it "returns a group client" do
+          expect(client.group).to be_instance_of(Group)
+        end
+      end
+    end
+
+    describe "#transfer" do
+      it "returns a transfer client" do
+        expect(client.transfer).to be_instance_of(Transfer)
+      end
+    end
+
+    describe "#schedule" do
+      it "returns a schedule client" do
+        expect(client.schedule).to be_instance_of(Schedule)
+      end
+    end
+  end
+
+  describe "api interactions" do
+    let(:username)    { 'vivian' }
+    let(:password)    { 'hunter2' }
+    let(:user)        { User.new(username, password) }
+    let(:fakesferatu) { FakeTransferatu.new(user) }
+    let(:host)        { 'transferatu.example.com' }
+    let(:client)      { Client.new(username, password, base_url: "https://#{host}") }
+
+    before do
+      ShamRack.mount(fakesferatu, host, 443)
+    end
+
+    after do
+      ShamRack.unmount_all
+    end
+
+    describe Group do
+      let(:group_name)    { "edna" }
+      let(:log_input_url) { "https://token:t.foo@logplex.example.com/logs" }
+
+      describe "#create" do
+        it "creates a new group" do
+          client.group.create("edna", log_input_url)
+          group = fakesferatu.groups.last
+          expect(group[:name]).to eq(group_name)
+          expect(group[:log_input_url]).to eq(log_input_url)
+        end
+      end
+
+      describe "#list" do
+        before do
+          fakesferatu.add_group('g1')
+          fakesferatu.add_group('g2')
+        end
+
+        it "lists existing groups" do
+          result = client.group.list
+          expect(result.count).to eq(2)
+          expect(result.first["name"]).to eq('g1')
+          expect(result.last["name"]).to eq('g2')
+        end
+      end
+
+      describe "#info" do
+        before do
+          fakesferatu.add_group(group_name, log_input_url)
+        end
+
+        it "returns details for the given group" do
+          info = client.group.info(group_name)
+          expect(info["name"]).to eq(group_name)
+          expect(info["log_input_url"]).to eq(log_input_url)
+        end
+      end
+
+      describe "#delete" do
+        before do
+          fakesferatu.add_group(group_name, log_input_url)
+        end
+
+        it "deletes the given group" do
+          client.group.delete(group_name)
+          deleted_group = fakesferatu.groups.find { |g| g[:name] == group_name }
+          expect(deleted_group[:deleted]).to be true
+        end
+      end
+    end
+
+    describe Transfer do
+      let(:g)         { "edna" }
+      let(:xfer_data) { { from_url: 'postgres:///test1',
+                         from_name: 'earl', from_type: 'pg_dump',
+                         to_url: 'postgres:///test2',
+                         to_name: 'mildred', to_type: 'pg_restore' } }
+
+      before do
+        fakesferatu.add_group(g)
+      end
+
+      describe "#create" do
+        it "creates a new transfer" do
+          client.group(g).transfer.create(xfer_data)
+          xfer = fakesferatu.last_transfer(g)
+          xfer_data.each do |k,v|
+            expect(xfer[k]).to eq(v)
+          end
+        end
+      end
+
+      describe "#list" do
+        before do
+          2.times { fakesferatu.add_transfer(g, Hash[xfer_data.map { |k, v| [k.to_s, v] }]) }
+        end
+
+        it "lists existing transfers" do
+          xfers = client.group(g).transfer.list
+          expect(xfers.count).to eq(2)
+          xfers.each do |xfer|
+            xfer_data.each do |k,v|
+              expect(xfer[k.to_s]).to eq(v)
+            end
+          end
+        end
+      end
+
+      describe "#info" do
+        before do
+          fakesferatu.add_transfer(g, Hash[xfer_data.map { |k, v| [k.to_s, v] }])
+        end
+
+        it "gets info for an existing transfer" do
+          id = fakesferatu.last_transfer(g)[:uuid]
+          xfer = client.group(g).transfer.info(id)
+          xfer_data.each do |k,v|
+            expect(xfer[k.to_s]).to eq(v)
+          end
+        end
+      end
+
+      describe "#delete" do
+        before do
+          fakesferatu.add_transfer(g, Hash[xfer_data.map { |k, v| [k.to_s, v] }])
+        end
+
+        it "deletes the given transfer" do
+          id = fakesferatu.last_transfer(g)[:uuid]
+          client.group(g).transfer.delete(id)
+          expect(fakesferatu.last_transfer(g)).to be_nil
+        end
+      end
+    end
+
+    describe Schedule do
+      let(:g)          { "edna" }
+      let(:sched_data) { { name: 'my schedule',
+                          callback_url: 'https://example.com/callback/foo',
+                          hour: 13,
+                          days: Date::DAYNAMES,
+                          timezone: 'UTC' } }
+
+      before do
+        fakesferatu.add_group(g)
+      end
+
+      describe "#create" do
+        it "creates a new schedule" do
+          client.group(g).schedule.create(sched_data)
+          sched = fakesferatu.last_schedule(g)
+          sched_data.each do |k,v|
+            expect(sched[k]).to eq(v)
+          end
+        end
+      end
+
+      describe "#list" do
+        before do
+          2.times { fakesferatu.add_schedule(g, Hash[sched_data.map { |k, v| [k.to_s, v] }]) }
+        end
+
+        it "lists existing schedules" do
+          scheds = client.group(g).schedule.list
+          expect(scheds.count).to eq(2)
+          scheds.each do |sched|
+            sched_data.each do |k,v|
+              expect(sched[k.to_s]).to eq(v)
+            end
+          end
+        end
+      end
+
+      describe "#info" do
+        before do
+          fakesferatu.add_schedule(g, Hash[sched_data.map { |k, v| [k.to_s, v] }])
+        end
+
+        it "gets info for an existing schedule" do
+          id = fakesferatu.last_schedule(g)[:uuid]
+          sched = client.group(g).schedule.info(id)
+          sched_data.each do |k,v|
+            expect(sched[k.to_s]).to eq(v)
+          end
+        end
+      end
+
+      describe "#delete" do
+        before do
+          fakesferatu.add_schedule(g, Hash[sched_data.map { |k, v| [k.to_s, v] }])
+        end
+
+        it "deletes the given schedule" do
+          id = fakesferatu.last_schedule(g)[:uuid]
+          client.group(g).schedule.delete(id)
+          expect(fakesferatu.last_schedule(g)).to be_nil
+        end
+      end
+    end
+  end
+end

data/xfrtuc.gemspec

@@ -0,0 +1,22 @@
+require_relative 'lib/xfrtuc'
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Maciek Sakrejda"]
+  gem.email         = ["m.sakrejda@gmail.com"]
+  gem.description   = %q{Transferatu client}
+  gem.summary       = %q{Transferatu client: see https://github.com/heroku/transferatu}
+  gem.homepage      = "https://github.com/heroku/xfrtuc"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "xfrtuc"
+  gem.require_paths = ["lib"]
+  gem.version       = Xfrtuc::VERSION
+  gem.license       = "MIT"
+
+  gem.add_runtime_dependency 'rest-client', '~> 1.6'
+
+  gem.add_development_dependency 'rspec', '~> 3.0'
+  gem.add_development_dependency 'sham_rack', '~> 1.3'
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: xfrtuc
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Maciek Sakrejda
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -58,7 +58,15 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- lib/xfrtuc.rb
+- spec/spec_helper.rb
+- spec/xfrtuc_spec.rb
+- xfrtuc.gemspec
 homepage: https://github.com/heroku/xfrtuc
 licenses:
 - MIT
@@ -83,5 +91,7 @@ rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: 'Transferatu client: see https://github.com/heroku/transferatu'
-test_files: []
+test_files:
+- spec/spec_helper.rb
+- spec/xfrtuc_spec.rb
 has_rdoc: