moy_sklad 1.0.0.beta1

data/spec/unit/company_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe 'Company' do
+
+  describe :index do
+    it "should return list of companies" do
+      comps = MoySklad::Model::Company.find(:all)
+      expect(comps.metadata[:total]).to eq(comps.length)
+    end
+  end
+
+  describe :find do
+    it "should find company" do
+      company = MoySklad::Model::Company.new
+      company.name = "Test company"
+      expect(company.save).to eq(true)
+
+      uuid = company.uuid
+
+      company = MoySklad::Model::Company.find(uuid)
+      expect(company.name).to eq("Test company")
+    end
+  end
+
+  describe :create do
+
+    it "should create and destroy new Company" do
+      company = MoySklad::Model::Company.new
+      company.name = "Test company"
+      expect(company.save).to eq(true)
+
+      expect(company.uuid.length).to eq(36)
+      uuid = company.uuid
+
+      company.destroy
+
+      expect{MoySklad::Model::Company.find(uuid)}.to raise_error(ActiveResource::ResourceNotFound)
+    end
+
+    it "should create new Company with complex attributes" do
+      company = MoySklad::Model::Company.new
+      company.name = "Complex test company"
+      company.contact.phones = "123456"
+      company.contact.email = "foo@bar.baz"
+      company.tags.tag = ["клиент", "дизайнер", "тест"]
+
+      expect(company.save).to eq(true)
+
+      uuid = company.uuid
+
+      company = MoySklad::Model::Company.find(uuid)
+      expect(company.contact.phones).to eq("123456")
+      expect(company.contact.email).to eq("foo@bar.baz")
+      expect(company.tags.tag).to match_array(["клиент", "дизайнер", "тест"])
+
+      company.destroy
+      expect{MoySklad::Model::Company.find(uuid)}.to raise_error(ActiveResource::ResourceNotFound)
+    end
+  end
+end

data/spec/unit/country_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe 'Country' do
+
+  describe :index do
+    it "should return list of countries" do
+      cl = MoySklad::Model::Country.find(:all)
+      expect(cl.metadata[:total]).to eq(cl.length)
+    end
+
+    it "should return correct uuid for code" do
+      uuid = MoySklad::Model::Country.uuid_from_code(643)
+      expect(uuid).to eq("9df7c2c3-7782-4c5c-a8ed-1102af611608")
+    end
+
+  end
+
+end

data/spec/unit/custom_entity_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe 'CustomEntity' do
+
+  describe :index do
+    it "should return list of custom entitities" do
+      ents = MoySklad::Model::CustomEntity.find(:all)
+      expect(ents.metadata[:total]).to eq(ents.length)
+    end
+  end
+
+  describe :find do
+    it "should return entity", pending: 'need real data in config' do
+      entity = MoySklad::Model::CustomEntity.new
+      entity.name = "повезу на собаках"
+      entity.entityMetadataUuid = CUSTOM_DICT[:delivery_method]
+      expect(entity.save).to eq(true)
+
+      expect(entity.uuid.length).to eq(36)
+      uuid = entity.uuid
+      entity = MoySklad::Model::CustomEntity.find(uuid)
+      expect(entity.entityMetadataUuid).to eq(CUSTOM_DICT[:payment_method])
+      expect(entity.name).to eq("Безналичная оплата")
+    end
+  end
+
+  describe :create do
+
+    it "should create and destroy new Entity", pending: 'need real data in config' do
+      entity = MoySklad::Model::CustomEntity.new
+      entity.name = "повезу на собаках"
+      entity.entityMetadataUuid = CUSTOM_DICT[:delivery_method]
+      expect(entity.save).to eq(true)
+
+      expect(entity.uuid.length).to eq(36)
+      uuid = entity.uuid
+
+      entity.destroy
+
+      expect{MoySklad::Model::CustomEntity.find(uuid)}.to raise_error(ActiveResource::ResourceNotFound)
+    end
+
+    it "should create, update and destroy new Entity", pending: 'need real data in config' do
+      entity = MoySklad::Model::CustomEntity.new
+      entity.name = "хочу бесплатно"
+      entity.entityMetadataUuid = CUSTOM_DICT[:payment_method]
+      expect(entity.save).to eq(true)
+
+      expect(entity.uuid.length).to eq(36)
+      uuid = entity.uuid
+
+      entity = MoySklad::Model::CustomEntity.find(uuid)
+      entity.name = "отработаю в поле"
+      expect(entity.save).to eq(true)
+
+      entity = MoySklad::Model::CustomEntity.find(uuid)
+      expect(entity.name).to eq("отработаю в поле")
+      expect(entity.entityMetadataUuid).to eq(CUSTOM_DICT[:payment_method])
+
+      entity.destroy
+      expect{MoySklad::Model::CustomEntity.find(uuid)}.to raise_error(ActiveResource::ResourceNotFound)
+    end
+  end
+end

data/spec/unit/customer_order_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe 'CustomerOrder' do
+
+  describe :index do
+
+    it "should enumerate orders, customers and goods (consistency test)" do
+      orders = MoySklad::Model::CustomerOrder.find(:all)
+      expect(orders.metadata[:total]).to eq(orders.length)
+
+      sample = 10
+      sample = orders.metadata[:total] if orders.metadata[:total] < 5
+
+      # Don't check ALL orders, only 5 or less
+      orders.to_a.sample(sample).each do |o|
+        cost = 0
+
+        ## We have "bad" order in test DB, just skip them
+        next if o.sourceAgentUuid.is_a?(MoySklad::Client::Attribute::MissingAttr)
+
+        expect(o.sourceAgentUuid.length).to eq(36) # uuid
+
+        customer = MoySklad::Model::Company.find(o.sourceAgentUuid)
+        # puts "#{o.uuid} [##{o.name}] by #{customer.name}"
+        o.to_a(:customerOrderPosition).each do |p|
+
+          cost += ((p.quantity.to_f * p.price.sum.to_f) / 100) ## XXX zero price found in invalid orders
+
+          expect(p.goodUuid.length).to eq(36) # uuid
+          good = MoySklad::Model::Good.find(p.goodUuid)
+          # puts " - #{good.uuid} [#{good.name}], #{p.quantity}"
+        end
+        # puts " total cost: #{cost}"
+      end
+    end
+  end
+
+  describe :find do
+    it "should return order" do
+      order = MoySklad::Model::CustomerOrder.new
+      order.name = "12345"
+      expect(order.save).to eq(true)
+      expect(order.uuid.length).to eq(36)
+      uuid = order.uuid
+      order = MoySklad::Model::CustomerOrder.find(uuid)
+      expect(order.name).to eq("12345")
+    end
+  end
+
+  describe :create do
+    it "should create new empty Order" do
+      order = MoySklad::Model::CustomerOrder.new
+      expect(order.save).to eq(true)
+      expect(order.uuid.length).to eq(36)
+      uuid = order.uuid
+      order.destroy
+      expect{MoySklad::Model::CustomerOrder.find(uuid)}.to raise_error(ActiveResource::ResourceNotFound)
+    end
+
+    it "should create new Order with values", pending: 'need real data in config' do
+      order = MoySklad::Model::CustomerOrder.new
+      order.name = "12345 - api test"
+      order.targetAgentUuid = TGT_AGENT
+      order.sourceStoreUuid = SRC_STORE
+      order.sourceAgentUuid = SRC_AGENT
+      expect(order.save).to eq(true)
+      expect(order.uuid.length).to eq(36)
+      uuid = order.uuid
+
+      order = MoySklad::Model::CustomerOrder.find(uuid)
+      expect(order.name).to eq("12345 - api test")
+      expect(order.targetAgentUuid).to eq(TGT_AGENT)
+      expect(order.sourceStoreUuid).to eq(SRC_STORE)
+      expect(order.sourceAgentUuid).to eq(SRC_AGENT)
+
+      customer = MoySklad::Model::Company.find(order.sourceAgentUuid)
+      expect(customer.name).to eq("Username")
+      order.destroy
+      expect{MoySklad::Model::CustomerOrder.find(uuid)}.to raise_error(ActiveResource::ResourceNotFound)
+    end
+
+    it "should create order with items and check cost", pending: 'need real data in config' do
+      order = MoySklad::Model::CustomerOrder.new
+      order.name = "12345 - api test [items]"
+      order.applicable = true
+      order.targetAgentUuid = TGT_AGENT
+      order.sourceStoreUuid = SRC_STORE
+      order.sourceAgentUuid = SRC_AGENT
+      order.stateUuid = CONFIRMED_UUID
+      order.sum.sum = "100"
+      order.sum.sumInCurrency = "100"
+
+      KNOWN_ITEMS.each do |id, info|
+        order.add_item(id, {quantity: info[:quantity],
+            basePrice: { sum: info[:price] * 100, sumInCurrency: info[:price] * 100},
+            price: { sum: info[:price] * 100, sumInCurrency: info[:price] * 100}})
+      end
+
+      ORDER_OPTIONS.each do |type, opt|
+        order.set_attribute({uuid: opt[:key], value: :entityValueUuid}, opt[:value])
+      end
+
+      expect(order.save).to eq(true)
+      expect(order.uuid.length).to eq(36)
+      uuid = order.uuid
+
+      order = MoySklad::Model::CustomerOrder.find(uuid)
+      expect(order.name).to eq("12345 - api test [items]")
+      expect(order.targetAgentUuid).to eq(TGT_AGENT)
+      expect(order.sourceStoreUuid).to eq(SRC_STORE)
+      expect(order.sourceAgentUuid).to eq(SRC_AGENT)
+      expect(order.stateUuid).to eq(CONFIRMED_UUID)
+
+      ORDER_OPTIONS.each do |type, opt|
+        expect(order.get_attribute(opt[:key]).entityValueUuid).to eq(opt[:value])
+      end
+
+      # This is NORMAL, order sum is always zero :D
+      expect(order.sum.sum).to eq("4.744008E7")
+      expect(order.sum.sumInCurrency).to eq("4.744008E7")
+
+      expect(order.customerOrderPosition.length).to eq(KNOWN_ITEMS.keys.length)
+      customer = MoySklad::Model::Company.find(order.sourceAgentUuid)
+      expect(customer.name).to eq("Username")
+
+      order.destroy
+      expect{MoySklad::Model::CustomerOrder.find(uuid)}.to raise_error(ActiveResource::ResourceNotFound)
+
+    end
+  end
+end

data/spec/unit/demand_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe 'Demand' do
+
+  describe :index do
+    it "should return list of demands" do
+      sups = MoySklad::Model::Demand.find(:all)
+      expect(sups.metadata[:total]).to eq(sups.length)
+    end
+  end
+
+  describe :find do
+    it "should return demand" do
+      demand = MoySklad::Model::Demand.find("91fbb933-5b4f-11e4-90a2-8ecb0019b941")
+      expect(demand.uuid).to eq("91fbb933-5b4f-11e4-90a2-8ecb0019b941")
+      expect(demand.to_a(:shipmentOut).length).to eq(1)
+    end
+  end
+
+  describe :create do
+
+    it "should create new empty Demand" do
+      demand = MoySklad::Model::Demand.new
+      demand.sourceStoreUuid = "b6fd1ae5-213c-11e4-a18f-002590a28eca"
+      demand.customerOrderUuid = "f4fc79f6-5b4b-11e4-7a07-673d00379d95"
+      expect(demand.save).to eq(true)
+      expect(demand.uuid.length).to eq(36)
+      demand.destroy
+    end
+
+    it "should create new non-empty Demand" do
+      demand = MoySklad::Model::Demand.new
+      demand.sourceStoreUuid = "b6fd1ae5-213c-11e4-a18f-002590a28eca"
+      demand.targetAgentUuid = "a114c0a4-5ab2-11e4-7a07-673d00178e52"
+      demand.sourceAgentUuid = "13187298-1ee5-11e4-7dd5-002590a28eca"
+      demand.customerOrderUuid = "f4fc79f6-5b4b-11e4-7a07-673d00379d95"
+      demand.applicable = true
+      demand.add_item("9eccf56d-5ab4-11e4-90a2-8ecb000e5298", { quantity: 850 })
+      expect(demand.save).to eq(true)
+      expect(demand.uuid.length).to eq(36)
+
+      uuid = demand.uuid
+      demand = MoySklad::Model::Demand.find(uuid)
+      expect(demand.sum.sum).to eq("0.0")
+      expect(demand.sum.sumInCurrency).to eq("0.0")
+      expect(demand.to_a(:shipmentOut).length).to eq(1)
+      demand.destroy
+
+      expect{MoySklad::Model::Demand.find(uuid)}.to raise_error(ActiveResource::ResourceNotFound)
+    end
+
+  end
+end

data/spec/unit/fail_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe "Some fail tests" do
+
+  it "should return error on save (invalid uuid)" do
+    p = MoySklad::Model::PaymentIn.new
+    p.demandsUuid = [nil]
+
+    expect(p.save).to eq(false)
+    expect(p.error.message).to eq("Invalid UUID string: ")
+  end
+end

data/spec/unit/good_folder_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe 'GoodFolder' do
+
+  describe :index do
+    it "should return list of folders" do
+      folders = MoySklad::Model::GoodFolder.find(:all)
+      expect(folders.metadata[:total]).to eq(folders.length)
+    end
+  end
+
+  describe :find do
+    it "should return item" do
+      folder = MoySklad::Model::GoodFolder.new
+      folder.name = "Test::top level"
+      expect(folder.save).to eq(true)
+      folder = MoySklad::Model::GoodFolder.find(folder.uuid)
+      expect(folder.name).to eq("Test::top level")
+    end
+  end
+
+  describe :create do
+
+    it "should create new GoodFolder" do
+      folder = MoySklad::Model::GoodFolder.new
+      folder.name = "Test folder"
+      expect(folder.save).to eq(true)
+      expect(folder.uuid.length).to eq(36)
+      folder.destroy
+    end
+
+    it "create tree" do
+      folder = MoySklad::Model::GoodFolder.new
+      folder.name = "Test::top level"
+      expect(folder.save).to eq(true)
+
+      subfolder = MoySklad::Model::GoodFolder.new({name: "Sublevel folder", parentUuid: folder.uuid})
+      expect(subfolder.save).to eq(true)
+
+      expect(subfolder.parentUuid).to eq(folder.uuid)
+
+      uuid = folder.uuid
+      suuid = subfolder.uuid
+
+      folder.destroy
+
+      expect{MoySklad::Model::GoodFolder.find(uuid)}.to raise_error(ActiveResource::ResourceNotFound)
+      expect{MoySklad::Model::GoodFolder.find(suuid)}.to raise_error(ActiveResource::ResourceNotFound)
+    end
+  end
+end

data/spec/unit/good_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+require 'securerandom'
+
+describe 'Good' do
+
+  describe :index do
+    it "should return list of items" do
+      items = MoySklad::Model::Good.find(:all)
+      expect(items.metadata[:total]).to eq(items.length)
+      len = items.metadata[:total]
+
+      # Newly update items, should be less then total
+      items = MoySklad::Model::Good.find(:all, params: { filter:  "updated>20141014010000"})
+      expect(items.metadata[:total]).to be < len
+    end
+  end
+
+  describe :find do
+    it "should return good" do
+      item = MoySklad::Model::Good.new
+      item.name = "Sample good"
+      item.save
+      item = MoySklad::Model::Good.find(item.uuid)
+      expect(item.name).to eq("Sample good")
+    end
+  end
+
+  describe "Simple attribute update" do
+    before(:all) do
+      item = MoySklad::Model::Good.new
+      item.name = "Simple test item for attr update test"
+      item.save
+      @uuid = item.uuid
+      @randomPrice = rand(1.0..100.0).round(2)
+    end
+
+    after(:all) do
+      MoySklad::Model::Good.find(@uuid).destroy
+    end
+
+    it "and update attr" do
+      item = MoySklad::Model::Good.find(@uuid)
+      expect(item.buyPrice).to eq("0.0")
+      item.buyPrice = @randomPrice
+      expect(item.save).to eq(true)
+    end
+
+    it "and read attr" do
+      item = MoySklad::Model::Good.find(@uuid)
+      expect(item.buyPrice.to_f).to eq(@randomPrice)
+    end
+  end
+
+  describe "create and update" do
+    it "should create a new Good" do
+      item = MoySklad::Model::Good.new
+      item.name = "Just a test item, с русскими букавами in da name"
+      item.description = "Отличный итем, шерстянной такой"
+      expect(item.save).to eq(true)
+
+      expect(item.uuid.length).to eq(36) # Should looks like real uuid
+
+      uuid = item.uuid
+
+      # Check item on server
+      item = MoySklad::Model::Good.find(uuid)
+      expect(item.uuid).to eq(uuid)
+
+      # Remove item
+      item.destroy
+
+      expect{MoySklad::Model::Good.find(uuid)}.to raise_error(ActiveResource::ResourceNotFound)
+    end
+
+    describe "should create item with salePrice and able to update only default",
+             pending: 'need real data in config' do
+      before(:all) do
+        item = MoySklad::Model::Good.new
+        item.name = "Test item with custom prices"
+
+        item.set_sale_price(PRICE_CUR, 100)
+
+        item.save
+        @uuid = item.uuid
+      end
+
+      after(:all) do
+        MoySklad::Model::Good.find(@uuid).destroy
+      end
+
+      it "and get price" do
+        item = MoySklad::Model::Good.find(@uuid)
+        expect(item.get_sale_price(PRICE_CUR).value.to_f / 100).to eq(100)
+      end
+
+      it "and update CUR price (only default price can be updated)" do
+        item = MoySklad::Model::Good.find(@uuid)
+
+        item.set_sale_price(PRICE_CUR, 1000)
+        expect(item.save).to eq(true)
+
+        expect(item.get_sale_price(PRICE_CUR).value.to_f / 100).to eq(1000)
+      end
+    end
+
+    describe "item with custom attributes" do
+      let(:partno)  { SecureRandom.hex }
+      let(:country) { SecureRandom.hex }
+      let(:link)    { SecureRandom.hex }
+
+      before(:all) do
+        item = MoySklad::Model::Good.new
+        item.name = "Test item with custom attributes"
+        item.save
+        @uuid = item.uuid
+      end
+
+      after(:all) do
+        MoySklad::Model::Good.find(@uuid).destroy
+      end
+
+      it "should test empty attrs", pending: 'need real data in config' do
+        item = MoySklad::Model::Good.find(@uuid)
+
+        expect(item.get_attribute(META_LINK[:uuid])).to be_nil
+        expect(item.get_attribute(META_ARTNO)).to be_nil
+        expect(item.get_attribute(META_COUNTRY)).to be_nil
+        expect{item.get_attribute("foo")}.to raise_error(ArgumentError)
+      end
+
+      it "set and read attrs", pending: 'need real data in config' do
+        item = MoySklad::Model::Good.find(@uuid)
+
+        item.set_attribute(META_COUNTRY, country)
+        item.set_attribute(META_LINK, link)
+        item.set_attribute(META_ARTNO, partno)
+
+        expect(item.save).to eq(true)
+
+        item = MoySklad::Model::Good.find(@uuid)
+        expect(item.get_attribute(META_LINK)).to eq(link)
+        expect(item.get_attribute(META_ARTNO)).to eq(partno)
+        expect(item.get_attribute(META_COUNTRY[:uuid]).valueString).to eq(country)
+      end
+
+    end
+  end
+
+end

data/spec/unit/payment_in_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe 'PaymentIn' do
+
+  describe :index do
+    it "should return list of payments" do
+      payments = MoySklad::Model::PaymentIn.find(:all)
+      expect(payments.metadata[:total]).to eq(payments.length)
+    end
+  end
+
+  describe :find do
+    it "should return payment" do
+      payment = MoySklad::Model::PaymentIn.new
+      payment.name = "test - payment"
+      payment.sum.sum = 1000 * 100
+      expect(payment.save).to eq(true)
+      expect(payment.uuid.length).to eq(36)
+
+      uuid = payment.uuid
+      payment = MoySklad::Model::PaymentIn.find(uuid)
+      expect(payment.name).to eq("test - payment")
+      expect(payment.sum.sum).to eq("100000.0")
+    end
+  end
+
+  describe :create do
+
+    it "should create new empty PaymentIn" do
+      payment = MoySklad::Model::PaymentIn.new
+      expect(payment.save).to eq(true)
+      expect(payment.uuid.length).to eq(36)
+      payment.destroy
+    end
+
+    it "should create new non-empty PaymentIn" do
+      payment = MoySklad::Model::PaymentIn.new
+      payment.name = "test - payment"
+      payment.sum.sum = 1000 * 100
+      expect(payment.save).to eq(true)
+      expect(payment.uuid.length).to eq(36)
+
+      uuid = payment.uuid
+      payment = MoySklad::Model::PaymentIn.find(uuid)
+      expect(payment.name).to eq("test - payment")
+      expect(payment.sum.sum).to eq("100000.0")
+      expect(payment.sum.sumInCurrency).to eq("100000.0")
+      payment.destroy
+
+      expect{MoySklad::Model::PaymentIn.find(uuid)}.to raise_error(ActiveResource::ResourceNotFound)
+    end
+
+    it "should create new order + payment", pending: 'need real data in config' do
+        order = MoySklad::Model::CustomerOrder.new
+        order.name = "Test with payment - API"
+        order.applicable = true
+        order.targetAgentUuid = TGT_AGENT
+        order.sourceStoreUuid = SRC_STORE
+        order.sourceAgentUuid = SRC_AGENT
+        order.stateUuid = CONFIRMED_UUID
+        order.sum.sum = "100"
+        order.sum.sumInCurrency = "100"
+
+        KNOWN_ITEMS.each do |id, info|
+          order.addItem(id, {quantity: info[:quantity],
+              basePrice: { sum: info[:price] * 100, sumInCurrency: info[:price] * 100},
+              price: { sum: info[:price] * 100, sumInCurrency: info[:price] * 100}})
+        end
+
+        ORDER_OPTIONS.each do |type, opt|
+          order.setAttribute({uuid: opt[:key], value: :entityValueUuid}, opt[:value])
+        end
+
+        expect(order.save).to eq(true)
+        expect(order.uuid.length).to eq(36)
+        uuid = order.uuid
+
+        payment = MoySklad::Model::PaymentIn.new
+        payment.sum.sum = order.sum.sum
+        payment.targetAgentUuid = TGT_AGENT
+        payment.sourceAgentUuid = SRC_AGENT
+        payment.describe = "Just a test"
+        payment.customerOrderUuid = uuid
+
+        expect(payment.save).to eq(true)
+        expect(payment.uuid.length).to eq(36)
+
+        # check order and bounded payment
+        order = MoySklad::Model::CustomerOrder.find(uuid)
+        expect(order.paymentsUuid.to_a(:financeInRef).first).to eq(payment.uuid)
+
+        # Order can be destroyed only after the payment
+        expect{order.destroy}.to raise_error(ActiveResource::ResourceNotFound)
+        payment.destroy
+        order.destroy
+    end
+
+    it "create payment and update applicable status", pending: 'need real data in config' do
+
+      payment = MoySklad::Model::PaymentIn.new
+      payment.targetAgentUuid = TGT_AGENT
+      payment.sourceAgentUuid = SRC_AGENT
+      payment.sum.sum = 1000 * 100
+      expect(payment.save).to eq(true)
+      uuid = payment.uuid
+
+      payment = MoySklad::Model::PaymentIn.find(uuid)
+      expect(payment.applicable).to eq("false")
+      payment.applicable = "true"
+      expect(payment.save).to eq(true)
+
+      payment = MoySklad::Model::PaymentIn.find(uuid)
+      expect(payment.applicable).to eq("true")
+
+      payment.destroy
+
+      expect{MoySklad::Model::PaymentIn.find(uuid)}.to raise_error(ActiveResource::ResourceNotFound)
+    end
+  end
+end