wetransfer 0.1.0 → 0.2.0

data/lib/wetransfer/version.rb

@@ -1,3 +0,0 @@
-module WeTransfer
-  VERSION = '0.1.0'.freeze
-end

data/spec/client_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-describe WeTransfer::Client do
-  describe 'Client#new' do
-    it 'returns a error when no api_key is given' do
-      expect {
-        described_class.new
-      }.to raise_error(ArgumentError, /missing keyword: api_key/)
-    end
-
-    it 'on initialization a active connection object is created' do
-      client = described_class.new(api_key: 'api-key')
-      expect(client.api_connection).to be_kind_of WeTransfer::Connection
-    end
-  end
-
-  describe 'Client#create_transfer' do
-    let(:client) { described_class.new(api_key: 'api-key') }
-
-    it 'create transfer should return a transfer object' do
-      transfer = client.create_transfer
-      expect(transfer.shortened_url).to start_with('http://we.tl/s-')
-      expect(transfer).to be_kind_of WeTransfer::Transfer
-    end
-
-    it 'when no name/description is send, a default name/description is generated' do
-      transfer = client.create_transfer
-      expect(transfer.name).to eq("File Transfer: #{Time.now.strftime('%d-%m-%Y')}")
-      expect(transfer.description).to eq('Transfer generated with WeTransfer Ruby SDK')
-    end
-
-    it 'when a name/description is send, transfer has that name/description' do
-      transfer = client.create_transfer(
-        name: 'WeTransfer Test Transfer',
-        description: "Moving along… Good news, everyone! I've
-        taught the toaster to feel love! Humans dating robots is
-        sick. You people wonder why I'm still single? It's 'cause
-        all the fine robot sisters are dating humans!")
-      expect(transfer.name).to eq('WeTransfer Test Transfer')
-      expect(transfer.description).to start_with('Moving along… Good news, everyone!')
-    end
-
-    it 'when no items are send, a itemless transfer is created' do
-      transfer = client.create_transfer
-      expect(transfer.items).to be_empty
-    end
-
-    it 'when items are sended, the transfer has items' do
-      transfer = client.create_transfer(items: ["#{__dir__}/fixtures/war-and-peace.txt"])
-      expect(transfer).to be_kind_of WeTransfer::Transfer
-      expect(transfer.items.count).to eq(1)
-    end
-
-    it 'returns an error when items are not sended inside an array' do
-      expect {
-        client.create_transfer(items: "#{__dir__}/war-end-peace.txt")
-      }.to raise_error(StandardError, 'The items field must be an array')
-    end
-
-    it 'completes a item after item upload' do
-      transfer = client.create_transfer(items: ["#{__dir__}/fixtures/war-and-peace.txt"])
-      expect(transfer).to be_kind_of WeTransfer::Transfer
-    end
-  end
-
-  describe 'Client#add_item' do
-    let(:client) { described_class.new(api_key: 'api-key') }
-
-    it 'add items to an already created transfer' do
-      transfer = client.create_transfer
-      expect(transfer.items.count).to eq(0)
-      transfer = client.add_items(transfer: transfer, items: ["#{__dir__}/fixtures/war-and-peace.txt"])
-      expect(transfer.items.count).to eq(1)
-    end
-
-    it 'raises an error when no transfer is being send to add_items_to_transfer method' do
-      expect {
-        client.add_items(items: ["#{__dir__}/fixtures/war-and-peace.txt"])
-        }.to raise_error(ArgumentError, 'missing keyword: transfer')
-    end
-  end
-end

data/spec/connection_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-describe WeTransfer::Connection do
-  describe 'Connection#new' do
-    it 'creates a new connection when the client is passed' do
-      client = OpenStruct.new(api_key: 'api-key-12345')
-      connection = described_class.new(client: client)
-      expect(connection.api_connection).to be_kind_of Faraday::Connection
-    end
-
-    it 'contains the api_key inside the connection' do
-      client = OpenStruct.new(api_key: 'api-key-12345')
-      connection = described_class.new(client: client)
-      expect(connection.api_key).to eq(client.api_key)
-    end
-
-    it 'correctly handles the connection path variable' do
-      ENV['WT_API_CONNECTION_PATH'] = '/this_path_does_not_exist'
-      client = OpenStruct.new(api_key: 'api-key-12345')
-      connection = described_class.new(client: client)
-      expect(connection.api_path).to eq('/this_path_does_not_exist')
-      ENV['WT_API_CONNECTION_PATH'] = '/v1'
-      connection = described_class.new(client: client)
-      expect(connection.api_path).to eq('/v1')
-    end
-  end
-
-  describe 'Connection#post_request' do
-    it 'returns with a response body when a post request is made' do
-      client = OpenStruct.new(api_key: 'api-key-12345')
-      connection = described_class.new(client: client)
-      response = connection.post_request(path: '/authorize')
-      expect(response['status']).to eq('success')
-    end
-
-    it 'returns with a response body when a post request is made' do
-      client = OpenStruct.new(api_key: 'api-key-12345')
-      connection = described_class.new(client: client)
-      response = connection.post_request(path: '/transfers', body: {name: 'test_transfer', description: 'this is a test transfer', items: []})
-      expect(response['shortened_url']).to start_with('http://we.tl/s-')
-      expect(response['name']).to eq('test_transfer')
-      expect(response['description']).to eq('this is a test transfer')
-      expect(response['items'].count).to eq(0)
-    end
-
-    it 'returns with a ApiRequestError when request is forbidden' do
-      client = OpenStruct.new(api_key: 'api-key-12345')
-      connection = described_class.new(client: client)
-      expect {
-        connection.post_request(path: '/forbidden')
-      }.to raise_error(WeTransfer::Connection::ApiRequestError, 'Forbidden')
-    end
-  end
-
-  describe 'Connection#get_request' do
-    it 'returns with a response body when a get request is made for upload urls' do
-      client = OpenStruct.new(api_key: 'api-key-12345')
-      connection = described_class.new(client: client)
-      response = connection.get_request(path: '/files/1337/uploads/1/7331')
-      expect(response['upload_url']).to include('upload')
-      expect(response['part_number']).to eq(1)
-      expect(response['upload_id']).to_not be_nil
-      expect(response['upload_expires_at']).to_not be_nil
-    end
-
-    it 'returns with a ApiRequestError when request is forbidden' do
-      client = OpenStruct.new(api_key: 'api-key-12345')
-      connection = described_class.new(client: client)
-      expect {
-        connection.get_request(path: '/forbidden')
-      }.to raise_error(WeTransfer::Connection::ApiRequestError, 'Forbidden')
-    end
-  end
-end

data/spec/item_builder_spec.rb

@@ -1,104 +0,0 @@
-require 'spec_helper'
-
-describe WeTransfer::ItemBuilder do
-  describe 'ItemBuilder process' do
-    let(:item_builder) { described_class.new }
-
-    it 'makes a new Item if no item is given on initialze' do
-      expect(item_builder).to be_an_instance_of(WeTransfer::ItemBuilder)
-      expect(item_builder.item).to be_an_instance_of(WeTransfer::Item)
-    end
-
-    it 'uses the item, when a item is given to the ItemBuilder' do
-      builder_item = described_class.new(item: item_builder.item)
-      expect(builder_item).to be_an_instance_of(WeTransfer::ItemBuilder)
-      expect(builder_item.item).to be_an_instance_of(WeTransfer::Item)
-    end
-
-    it 'sets the path when path method is called' do
-      item_builder.path(path: "#{__dir__}/fixtures/war-and-peace.txt")
-      expect(item_builder.item.path).to eq("#{__dir__}/fixtures/war-and-peace.txt")
-    end
-
-    it 'sets content always to file' do
-      item_builder.content_identifier
-      expect(item_builder.item.content_identifier).to eq('file')
-    end
-
-    it 'sets the local local_identifier to the first 36 characters of the file name' do
-      item_builder.path(path: "#{__dir__}/fixtures/war-and-peace.txt")
-      item_builder.local_identifier
-      expect(item_builder.item.local_identifier).to eq('war-and-peace.txt')
-      expect(item_builder.item.local_identifier.length).to be <= 36
-    end
-
-    it 'sets the local local_identifier to the first 36 characters of the file name' do
-      item_builder.path(path: "#{__dir__}/fixtures/war-and-peace-and-peace-and-war-and-war-and-peace.txt")
-      item_builder.local_identifier
-      expect(item_builder.item.local_identifier).to eq('war-and-peace-and-peace-and-war-and-')
-      expect(item_builder.item.local_identifier.length).to be <= 36
-    end
-
-    it 'sets the item name according to the given path' do
-      item_builder.path(path: "#{__dir__}/fixtures/war-and-peace.txt")
-      item_builder.name
-      expect(item_builder.item.name).to eq('war-and-peace.txt')
-    end
-
-    it 'sets the filesize by reading the file' do
-      item_builder.path(path: "#{__dir__}/fixtures/war-and-peace.txt")
-      item_builder.size
-      expect(item_builder.item.size).to_not be_nil
-      expect(item_builder.item.size).to eq(485192)
-    end
-
-    it 'sets the id according to the api response' do
-      item_builder.path(path: "#{__dir__}/fixtures/war-and-peace.txt")
-      item_builder.id(item: item_builder.item, id: 1234)
-      expect(item_builder.item.id).to eq(1234)
-    end
-
-    it 'sets the upload url according to the api response' do
-      item_builder.path(path: "#{__dir__}/fixtures/war-and-peace.txt")
-      item_builder.upload_url(item: item_builder.item, url: "#{ENV.fetch('WT_API_URL')}/upload/#{SecureRandom.hex(9)}")
-      expect(item_builder.item.upload_url).to_not be_nil
-    end
-
-    it 'sets the multipart_parts according to the api response' do
-      item_builder.path(path: "#{__dir__}/fixtures/war-and-peace.txt")
-      item_builder.multipart_parts(item: item_builder.item, part_count: 3)
-      expect(item_builder.item.multipart_parts).to eq(3)
-    end
-
-    it 'sets the multipart_id according to the api response' do
-      item_builder.path(path: "#{__dir__}/fixtures/war-and-peace.txt")
-      item_builder.multipart_id(item: item_builder.item, multi_id: 1234567890)
-      expect(item_builder.item.multipart_id).to eq(1234567890)
-    end
-
-    it 'sets the upload_id according to the api response' do
-      item_builder.path(path: "#{__dir__}/fixtures/war-and-peace.txt")
-      item_builder.upload_id(item: item_builder.item, upload_id: 1234567890)
-      expect(item_builder.item.upload_id).to eq(1234567890)
-    end
-
-    it 'returns the item object when ItemBuilder item method is calles' do
-      item_builder.path(path: "#{__dir__}/fixtures/war-and-peace.txt")
-      expect(item_builder.item).to be_an_instance_of(WeTransfer::Item)
-    end
-
-    it 'validates the file if it exists on the path given' do
-      expect {
-        item_builder.path(path: "#{__dir__}/fixtures/war-and-peace.txt")
-        item_builder.validate_file
-      }.to_not raise_error
-    end
-
-    it 'validates the file if it exists on the path given and returns with FileDoesNotExistError' do
-      expect {
-        item_builder.path(path: "#{__dir__}/peace-and-war.txt")
-        item_builder.validate_file
-      }.to raise_error(WeTransfer::ItemBuilder::FileDoesNotExistError, "#{item_builder.item} does not exist")
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,24 +0,0 @@
-require 'simplecov'
-SimpleCov.start do
-  add_filter '/spec/'
-end
-
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-
-require 'wetransfer'
-require 'pry'
-require 'rspec'
-require_relative 'test_server'
-
-RSpec.configure do |config|
-  config.before :suite do
-    TestServer.start(nil)
-    ENV['WT_API_URL'] = 'http://localhost:9001'
-    ENV['WT_API_CONNECTION_PATH'] = '/v1'
-  end
-
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-end

data/spec/test_server.rb

@@ -1,208 +0,0 @@
-require 'webrick'
-require 'securerandom'
-include WEBrick
-
-class ForbiddenServlet < HTTPServlet::AbstractServlet
-  def do_GET(_req, res)
-    res['Content-Type'] = 'application/json'
-    res.status = 403
-  end
-  def do_POST(_req, res)
-    res['Content-Type'] = 'application/json'
-    res.status = 403
-  end
-end
-
-class AuthServlet < HTTPServlet::AbstractServlet
-  def do_POST(req, res)
-    if req.header["x-api-key"].empty?
-      res['Content-Type'] = 'application/json'
-      res.status = 401
-    else
-      res['Content-Type'] = 'application/json'
-      res.status = 200
-      res.body = {status: 'success', token: SecureRandom.hex(4)}.to_json
-    end
-  end
-end
-
-class TransfersServlet < HTTPServlet::AbstractServlet
-  def self.do_POST(req, res)
-    content = JSON.parse(req.body)
-    items_count = content["items"].count || 0
-    res['Content-Type'] = 'application/json'
-    res.status = 200
-    res.body = {shortened_url: "http://we.tl/s-#{SecureRandom.hex(5)}",
-                id: SecureRandom.hex(9),
-                name: content["name"],
-                description: content["description"],
-                size: totalsize_calc(items: content["items"]),
-                total_items: content["items"].count,
-                version_identifier: nil,
-                state: 'uploading',
-                items: item_params(items: content["items"])}.to_json
-  end
-
-  private
-
-  def self.item_params(items:)
-    items_array = []
-    items.each do |item|
-      items_array << {id: SecureRandom.hex(9),
-                      local_identifier: item['filename'][0..36],
-                      name: item['filename'],
-                      size: item['filesize'],
-                      meta:{
-                        multipart_parts: multipart_calc(item: item),
-                        multipart_id: SecureRandom.hex(9),
-                      },
-                      upload_url:"#{ENV.fetch('WT_API_URL')}/upload/#{SecureRandom.hex(9)}",
-                      upload_id: SecureRandom.hex(9),
-                      upload_expires_at: (Time.now + 5).to_i
-                    }
-    end
-    return items_array
-  end
-
-  def self.totalsize_calc(items:)
-    total_size = []
-    items.each do |item|
-      total_size << item['filesize']
-    end
-    total_size.reduce(0, :+)
-  end
-
-  def self.multipart_calc(item:)
-    parts = item['filesize'] / 6291456
-    parts == 0 ? 1 : parts
-  end
-end
-
-class UploadUrlServlet < HTTPServlet::AbstractServlet
-  def self.do_GET(_req, res)
-    part_number = res.request_uri.to_s.split('/')[-2]
-    res['Content-Type'] = 'application/json'
-    res.status = 200
-    res.body = {  upload_url: "#{ENV.fetch('WT_API_URL')}/upload/#{SecureRandom.hex(9)}",
-                  part_number: part_number.to_i,
-                  upload_id: SecureRandom.hex(9),
-                  upload_expires_at: (Time.now + 5).to_i
-                }.to_json
-  end
-end
-
-class UploadPartServlet < HTTPServlet::AbstractServlet
-  def self.do_PUT(_req, res)
-    res['Content-Type'] = 'application/json'
-    res.status = 200
-  end
-end
-
-class TransferItemServlet < HTTPServlet::AbstractServlet
-  # this servlet is used for add_items_to_transfer functionality
-  def self.do_POST(req, res)
-    content = JSON.parse(req.body)
-    res['Content-Type'] = 'application/json'
-    res.status = 200
-    res.body = item_params(items: content["items"]).to_json
-  end
-
-  def self.item_params(items:)
-    items_array = []
-    items.each do |item|
-      items_array << {id: SecureRandom.hex(9),
-                      local_identifier: item['filename'][0..36],
-                      name: item['filename'],
-                      size: item['filesize'],
-                      meta:{
-                        multipart_parts: multipart_calc(item: item),
-                        multipart_id: SecureRandom.hex(9),
-                      },
-                      upload_url:"#{ENV.fetch('WT_API_URL')}/upload/#{SecureRandom.hex(9)}",
-                      upload_id: SecureRandom.hex(9),
-                      upload_expires_at: (Time.now + 5).to_i
-                    }
-    end
-    return items_array
-  end
-  def self.multipart_calc(item:)
-    parts = item['filesize'] / 6291456
-    parts == 0 ? 1 : parts
-  end
-end
-
-class UploadServlet < HTTPServlet::AbstractServlet
-  def do_PUT(req, res)
-    res['Content-Type'] = 'application/json'
-    res.status = 200
-  end
-end
-
-class CompleteItemServlet < HTTPServlet::AbstractServlet
-  def self.do_POST(_req, res)
-    res['Content-Type'] = 'application/json'
-    res.status = 202
-    res.body = {ok: true, message: 'File is marked as complete.'}.to_json
-  end
-end
-
-class TestServer
-  def self.start(log_file = nil, port = 9001)
-    new(log_file, port).start
-  end
-
-  def initialize(log_file = nil, port = 9001)
-    log_file ||= StringIO.new
-    log = WEBrick::BasicLog.new(log_file, WEBrick::BasicLog::WARN)
-
-    options = {
-      Port: port,
-      Logger: log,
-      AccessLog: [
-        [log, WEBrick::AccessLog::COMMON_LOG_FORMAT],
-        [log, WEBrick::AccessLog::REFERER_LOG_FORMAT]
-      ],
-      DocumentRoot: File.expand_path(__dir__),
-    }
-
-    @server = WEBrick::HTTPServer.new(options)
-    @server.mount('/v1/forbidden',     ForbiddenServlet)
-    @server.mount('/v1/authorize',  AuthServlet)
-    @server.mount_proc('/v1/transfers') do |req, res|
-      if req.path =~ /^(?=.*\bv1\b)(?=.*\btransfers\b)(?=.*\bitems\b).+/
-        TransferItemServlet.do_POST(req, res)
-      else
-        TransfersServlet.do_POST(req, res)
-      end
-    end
-    @server.mount_proc('/v1/files/') do |req, res|
-      if req.request_method == "PUT"
-        UploadPartServlet.do_PUT(req, res)
-      elsif req.request_method == "GET"
-        UploadUrlServlet.do_GET(req, res)
-      else
-        CompleteItemServlet.do_POST(req,res)
-      end
-    end
-    @server.mount('/upload', UploadServlet)
-  end
-
-  def start
-    trap('INT') {
-      begin
-        @server.shutdown unless @server.nil?
-      rescue Object => e
-        warn "Error #{__FILE__}:#{__LINE__}\n#{e.message}"
-      end
-    }
-
-    @thread = Thread.new { @server.start }
-    Thread.pass
-    self
-  end
-
-  def join
-    @thread.join if defined? @thread and @thread
-    self
-  end
-end