test_sdk1 1.0.0

data/spec/mainnet_spec.rb

@@ -0,0 +1,452 @@
+# mainnet_spec.rb
+require './lib/rpc/rpc_client.rb'
+
+# Ip Address taken from Mainnet
+# client = Casper::RpcClient.new("5.161.68.4")
+client = Casper::RpcClient.new("65.108.78.120")
+# block_Hash taken from MainNet
+block_hash = "5fdbdf3fa70d37821aa2d1752743e9653befc15e65e40c2655e1ce93a807260f"
+# deploy_Hash taken from MainNet
+deploy_hash = "52a40996a88523c475c12e5370ff90b0ae4ec051cfaa57cd048c136b1a83319d"
+state_root_hash = "7b605ad991c949832fd966495afc3f97a2b8122a1a6afc2610b545a8c07e3456"
+item_key = "f870e3cadfde21d7d7686fdf3d1a8413838274d363ca7b27ae71fc9125eb6743"
+uref = "uref-0d689e987db7ee5be246282c3a7badf0411e34baeeab8e9d73c1223ae4ad02e5-007"
+describe Casper::RpcClient do
+  url = "65.21.0.X" 
+  client2 = Casper::RpcClient.new(url)   
+  it "fails, wrong ip format :  #{url}" do  
+    expect(client2.get_error).to eql("SocketError") 
+  end 
+  url = "65.21.0.0"  
+  client3 = Casper::RpcClient.new(url)  
+  it "fails, #{url} is not available in network" do  
+    expect(client3.get_error).to eql("Errno::ECONNREFUSED") 
+  end
+  # Test info_get_peers()
+  describe "#info_get_peers" do
+    peers = client.info_get_peers 
+    context "Peers Array" do
+      it "passes, peers array is not nil" do 
+        expect(peers).to be_truthy
+      end
+     
+      it "passes, peers array is not empty" do 
+        expect(peers).not_to be_empty
+      end
+     
+      # it "passes, size of both peer arrays are equal" do
+      #   # Check the length of the peers array 
+      #   client2 = Casper::RpcClient.new("34.192.231.34")
+      #   other_peers = client2.info_get_peers
+      #   expect(peers.size).to eql(other_peers.size)
+      # end
+     
+      it "passes, peers object is a type of Array" do
+        # Check whether ıt is an array or not
+        expect(client.info_get_peers).to be_an(Array)
+        # Check the length of the peers array 
+        expect(client.info_get_peers.length).to be > 0
+      end
+
+      it "passes, peers member are types of Hash" do
+        # Check type of peers elements
+        expect(peers[0]).to be_an_instance_of(Hash)
+      end
+        
+      peer = peers[0]
+      first_item = peer["node_id"]
+      second_item = peer["address"]
+      it "passes, peer members are types of String" do
+          expect(first_item).to be_an_instance_of(String)
+          expect(second_item).to be_an_instance_of(String)
+          expect(first_item.length).to eq(14)
+      end
+      
+      it "passes, length of first_item equal #{first_item.length}"  do
+          expect(first_item.length).to eq(14)
+      end
+      
+      peer.deep_symbolize_keys!
+      it "passes, peer includes node_id key" do
+          expect(peer).to have_key(:node_id)
+      end
+
+      it "passes, peer includes address key" do
+          expect(peer).to have_key(:address)
+      end
+    end
+    context "When called info_get_peers with invalid ip address" do   
+      client4 = Casper::RpcClient.new("65.21.227.X") 
+      # puts client4.info_get_peers 
+      it "fails,  \"#{client4.info_get_peers}\"" do   
+        expect(client4.info_get_peers).to eql("SocketError")  
+      end 
+    end
+  end  
+
+  # Test chain_get_StateRootHash 
+  describe "#chain_get_StateRootHash" do
+    context "Without a block_hash parameter" do 
+      current_state_root_hash = client.chain_get_StateRootHash("")
+      it "passes,  current state_root_hash is a type of String" do
+        expect(current_state_root_hash).to be_an(String)
+      end
+
+      it "passes,  current state_root_hash is not nil" do
+        expect(current_state_root_hash).to be_truthy
+      end
+
+      it "passes,  current state_root_hash is not empty" do
+        expect(current_state_root_hash).not_to be_empty
+      end
+
+      it "passes,  current state_root_hash is 64 characters long" do
+        expect(current_state_root_hash.length).to eq(64)
+      end
+    end
+
+    context "With a block_hash parameter" do 
+      current_state_root_hash = client.chain_get_StateRootHash(state_root_hash)
+      it "passes,  current state_root_hash is a type of String" do
+        expect(current_state_root_hash).to be_an(String)
+      end
+
+      it "passes,  current state_root_hash is not nil" do
+        expect(current_state_root_hash).to be_truthy
+      end
+
+      it "passes,  current state_root_hash is not empty" do
+        expect(current_state_root_hash).not_to be_empty
+      end
+
+      it "passes,  current state_root_hash is 64 characters long" do
+        expect(current_state_root_hash.length).to eq(64)
+      end
+    end
+  end  
+
+  # Test info_get_deploy(deploy_hash)
+  describe "#info_get_deploy" do 
+    context "When info_get_deploy method is called with deploy hash parameter" do 
+        deploy = client.info_get_deploy(deploy_hash)
+        deploy.deep_symbolize_keys!
+        payment = deploy[:payment]
+        session = deploy[:session]
+        approvals = deploy[:approvals]
+      it "passes, Deploy type is a Hash" do 
+        expect(deploy).to be_a(Hash)
+      end
+     
+      it "passes, hash value of Deploy is equal to the deploy_hash value" do 
+        hash_value = deploy[:hash]
+        expect(hash_value).to eql(deploy_hash)
+      end
+     
+      it "passes, header is not nil" do 
+        header = deploy[:header]
+        expect(header).to be_truthy
+      end
+     
+      it "passes, payment is not nil" do 
+        expect(payment).to be_truthy
+      end
+     
+      it "passes, payment includes ModuleBytes key" do 
+        # module_bytes = payment[:ModuleBytes]
+        # key_variable = :ModuleBytes
+        expect(payment).to have_key(:ModuleBytes)
+      end
+    
+      it "passes, session is not nil" do 
+        expect(session).to be_truthy
+        expect(session).to be_an_instance_of(Hash)
+      end
+    
+      it "passes, session includes StoredContractByHash key" do 
+        expect(session).to have_key(:StoredContractByHash)
+      end
+    
+      it "passes, approvals is not nil" do 
+        expect(approvals).to be_truthy
+        expect(approvals).to be_an_instance_of(Array)
+      end
+      
+      it "passes, approvals includes signer" do 
+        expect(approvals[0]).to have_key(:signer)
+      end
+
+      it "passes, approvals includes signature" do 
+        expect(approvals[0]).to have_key(:signature)
+      end
+    end
+
+    context "When info_get_deploy is called with an empty deploy hash parameter" do  
+      it "fails,  ServerError: Invalid params " do
+        err = client.info_get_deploy("")
+        # err = "Server error -32602: Invalid params (Jimson::Client::Error::ServerError)"
+        expect {raise StandardError, err}.
+        to raise_error(err)
+      end
+    end
+
+    context "When info_get_deploy is called with an invalid parameter" do  
+      it "fails,  ServerError: Invalid params " do
+        err = client.info_get_deploy("AAAAAAA146419d036d13b83f37e7580df1ddfd925fbe4b36ee90f9d6fd63b9bb")
+        expect {raise StandardError, err}.
+        to raise_error(err)
+      end      
+      it "fails,  ServerError: Invalid params " do
+        err = client.info_get_deploy("asdsadsadsa")
+        expect {raise StandardError, err}.
+        to raise_error(err)
+      end
+    end
+  end
+
+  # Test info_get_status()
+  describe "#info_get_status" do
+    node_status = client.info_get_status
+    node_status.deep_symbolize_keys!
+    context "Returns the current status of the node" do 
+      it "passes, node includes api_version, chainspec_name, starting_state_root_hash, peers, last_added_block_info, our_public_signing_key, round_length, next_upgrade, build_version, uptime keys" do
+        expect(node_status).to have_key(:api_version)
+        expect(node_status).to have_key(:chainspec_name)
+        expect(node_status).to have_key(:starting_state_root_hash)
+        expect(node_status).to have_key(:peers)
+        expect(node_status).to have_key(:last_added_block_info)
+        expect(node_status).to have_key(:our_public_signing_key)
+        expect(node_status).to have_key(:round_length)
+        expect(node_status).to have_key(:next_upgrade)
+        expect(node_status).to have_key(:build_version)
+        expect(node_status).to have_key(:uptime)
+      end
+
+      it "passes, network is casper" do 
+        chainspec_name = node_status[:chainspec_name]
+        expect(chainspec_name).to eql("casper")
+      end
+
+      it "passes, last added block includes hash, timestamp, era_id, height, state_root_hash, creator keys" do  
+        last_block = node_status[:last_added_block_info]
+        expect(last_block).to have_key(:hash)
+        expect(last_block).to have_key(:timestamp)
+        expect(last_block).to have_key(:era_id)
+        expect(last_block).to have_key(:state_root_hash)
+        expect(last_block).to have_key(:creator)
+      end
+
+      it "passes, the number of peers are equal" do
+        peers_from_info_get_peers = client.info_get_peers
+        peers_from_info_get_status = node_status[:peers]
+        expect(peers_from_info_get_status.size).to be > 0
+        expect(peers_from_info_get_peers.size).to be > 0
+      end
+
+      it "passes, node public key is : 014382d46e2543ab2832c04936f8c205847040426abb56065bbf7b2f7e1d33f200" do
+        our_public_signing_key = "014382d46e2543ab2832c04936f8c205847040426abb56065bbf7b2f7e1d33f200"
+        expect(node_status[:our_public_signing_key]).to eql(our_public_signing_key)
+      end
+    end
+  end
+
+  # Test chain_get_block_transfers(block_hash)
+  describe "#chain_get_block_transfers" do 
+    transfers = client.chain_get_block_transfers(block_hash)
+    context "Returns all transfers for a Block from the network" do 
+      it "passes, transfers is not empty and the number of transfers is #{transfers.size}" do  
+        expect(transfers).not_to be_empty
+        expect(transfers.size).to eql(2)
+      end
+
+      it "passes, amount of the first transaction is 6000000000000 motes" do 
+        first_transaction = transfers[0].deep_symbolize_keys!
+        first_transfer_amount = 6000000000000
+        expect(first_transaction[:amount].to_i).to eql(first_transfer_amount)
+      end
+  
+      it "passes, amount of the second transaction is 3997300000000 motes" do 
+        second_transaction = transfers[1].deep_symbolize_keys!
+        second_transfer_amount = 3997300000000
+        expect(second_transaction[:amount].to_i).to eql(second_transfer_amount)
+      end
+
+      it "passes, all keys in transfers are \'deploy_hash\', \'from\', \'to\', 
+      \'source\', \'target\', \'amount\', \'gas\', \'id\' respectively" do
+        transfers = transfers[0]
+        transfers.deep_symbolize_keys!
+        expect(transfers).to have_key(:deploy_hash)
+        expect(transfers).to have_key(:from)
+        expect(transfers).to have_key(:to)
+        expect(transfers).to have_key(:source)
+        expect(transfers).to have_key(:target)
+        expect(transfers).to have_key(:amount)
+        expect(transfers).to have_key(:gas)
+        expect(transfers).to have_key(:id)
+      end
+    end
+  end
+
+  # Test chain_get_block(block_hash)
+  describe "#chain_get_block" do  
+    block_hash = "5fdbdf3fa70d37821aa2d1752743e9653befc15e65e40c2655e1ce93a807260f"
+    block = client.chain_get_block(block_hash)
+    block.deep_symbolize_keys!
+    header = block[:header]
+    body = block[:body]
+    describe "Returns a Block from the network" do 
+      context "When chain_get_block method is called with deploy hash parameter" do 
+        it "passes, block hash : #{block[:hash]}" do 
+          expect(block[:hash]).to be_truthy
+          expect(block[:hash]).to be_a(String)
+          expect(block[:hash]).not_to be_empty
+          expect(block[:hash].length).to eql(64)
+        end
+        
+        it "passes, hash value of block is equal to the block hash given as parameter" do  
+          expect(block[:hash]).to eq(block_hash)   
+        end
+
+        it "passes, block includes \'hash\', \'header\', \'body\' and \'proofs\' respectively" do  
+          expect(block).to have_key(:hash)
+          expect(block).to have_key(:header)
+          expect(block).to have_key(:body)
+          # expect(block).to have_key(:testtest) # Negative test, uncomment and test again to see the result.
+        end
+        
+        it "passes, header includes \'parent_hash\', \'state_root_hash\', \'body_hash\', \'random_bit\', 
+        \'accumulated_seed\', \'era_end\', \'timestamp\', \'era_id\', \'height\', \'protocol_version\' keys respectively" do  
+          expect(header).to have_key(:parent_hash)
+          expect(header[:parent_hash]).not_to be_empty        # parent_hash is not empty
+          expect(header).to have_key(:state_root_hash)
+          expect(header[:state_root_hash]).not_to be_empty    # state_root_hash is not empty
+          expect(header).to have_key(:body_hash)
+          expect(header[:body_hash]).not_to be_empty          # body_hash is not empty
+          expect(header).to have_key(:random_bit)
+          expect(header[:random_bit]).to be_truthy            # random_bit is true
+          expect(header).to have_key(:accumulated_seed)
+          expect(header[:accumulated_seed]).not_to be_empty   # accumulated_seed is not empty
+          expect(header).to have_key(:era_end)
+          expect(header[:era_end]).to be_falsey              # era_end is not nil
+          expect(header).to have_key(:timestamp)
+          expect(header[:timestamp]).not_to be_empty          # timestamp is not nil
+          expect(header).to have_key(:height)
+          expect(header[:height]).to be_truthy                # height is not nil
+          expect(header).to have_key(:protocol_version)
+          expect(header[:protocol_version]).to be_truthy      # protocol_version is not nil
+          # expect(header).to have_key(:testtest) # Negative test, uncomment and test again to see the result.
+        end
+
+        it "passes, body includes \'proposer\', \'deploy_hashes\' and \'transfer_hashes\' keys respectively" do 
+          expect(body).to have_key(:proposer)
+          expect(body[:proposer]).not_to be_empty
+          expect(body).to have_key(:deploy_hashes)
+          expect(body[:deploy_hashes]).to be_a_kind_of(Array)
+          expect(body).to have_key(:transfer_hashes)
+          expect(body[:transfer_hashes]).to be_a_kind_of(Array)
+          # expect(body).to have_key(:testtest) # Negative test, uncomment and test again to see the result.
+        end
+
+        it "includes public_key and signature keys" do
+          proofs = block[:proofs]
+          proof_item = proofs[0]
+          expect(proof_item).to have_key(:public_key)
+          expect(proof_item[:public_key]).not_to be_empty
+          expect(proof_item).to have_key(:signature)
+          expect(proof_item[:signature]).not_to be_empty
+          # expect(proof_item).to have_key(:testtest)  # Negative test, uncomment and test again to see the result.
+        end
+      end
+      context "When chain_get_block method is called without deploy hash parameter" do 
+        # Add tests
+      end
+    end
+  end
+
+  # Test chain_get_eraInfo_by_SwitchBlock(block_hash)
+  describe "#chain_get_eraInfo_by_SwitchBlock" do 
+    context "Returns an EraInfo from the network" do 
+      switch_block_hash = "4696285db1ca6572f425cada612257f85a58a6a4034c09846afe360ba40e5df0"
+      era_summary = client.chain_get_eraInfo_by_SwitchBlock(switch_block_hash)
+      
+      if era_summary.class == Hash
+        era_summary.deep_symbolize_keys!
+
+        era_id = 3663
+        it "checks whether era_ids are equal or not" do 
+          expect(era_summary[:era_id]).to eql(era_id)
+        end
+       
+        state_root_hash = "4f9929288b885bb4eae3c27aaf13c974e1fc79eb12be5c6064e316e5797ca4ec"
+        it "checks whether state_root_hashes are equal or not" do 
+          expect(era_summary[:state_root_hash]).to eql(state_root_hash)
+        end
+      end
+    end
+  end
+
+  # Test state_get_item(state_root_hash, key, path)
+  describe "#state_get_item" do 
+    context "Returns a stored value from the network" do 
+      stored_value = client.state_get_item("647C28545316E913969B032Cf506d5D242e0F857061E70Fb3DF55980611ace86", "bid-24b6D5Aabb8F0AC17D272763A405E9CECa9166B75B745Cf200695E172857c2dD", [])
+      stored_value.deep_symbolize_keys!
+
+      validator_public_key = "012bac1d0ff9240ff0b7b06d555815640497861619ca12583ddef434885416e69b"
+      stored_value[:Bid][:validator_public_key]
+
+      it "checks validator_public_key equality" do  
+        expect(stored_value[:Bid][:validator_public_key]).to eql(validator_public_key)
+      end
+
+      staked_amount = 208330980103513
+      it "checks staked_amount which is 208330980103513" do 
+        expect(stored_value[:Bid][:staked_amount].to_i).to eql(208330980103513)
+      end
+     
+      it "includes initial_release_timestamp_millis keys" do  
+        expect(stored_value[:Bid][:vesting_schedule]).to have_key(:initial_release_timestamp_millis)
+      end
+    end
+  end
+
+  # Test state_get_dictionary_item(state_root_hash, item_key, uref)
+  describe "#state_get_dictionary_item" do 
+    stored_value = client.state_get_dictionary_item("d5811c438982f231a9152011c0f6ce9ae9c716e8075a6edec8390f10072ecd29","f870e3cadfde21d7d7686fdf3d1a8413838274d363ca7b27ae71fc9125eb6743", "uref-0d689e987db7ee5be246282c3a7badf0411e34baeeab8e9d73c1223ae4ad02e5-007")
+    stored_value.deep_symbolize_keys!
+    it "checks that CLValue should not be nil" do  
+      expect(stored_value[:CLValue]).to be_truthy
+    end
+
+    it "checks that cl_type should equal to String" do  
+      expect(stored_value[:CLValue][:cl_type]).to eql("String")
+    end
+
+    it "checks that CLValue parsed equals to \"https://caspercommunity.io\"" do  
+      expect(stored_value[:CLValue][:parsed]).to eql("https://caspercommunity.io")
+    end
+  end
+
+  # Test state_get_balance(state_root_hash, balance_uref)
+  describe "#state_get_balance" do 
+    balance = client.state_get_balance("610e932aef10d3e1fa04940c79a4a2789ee79c17046f1a9b45a2919f3600f3d5", "uref-7de5e973b7d70bc2b328814411f2009aafd8dba901cfc2c588ba65088dcd22bb-007")
+
+    it "is equal to 29269647684075" do  
+      expect(balance.to_i).to eql(29269647684075)
+    end
+  end
+
+  # Test state_get_AuctionInfo
+  describe "#state_get_AuctionInfo" do
+    auction_state = client.state_get_AuctionInfo  
+    if auction_state.class == Hash
+      auction_state.deep_symbolize_keys!
+      it "checks state root hash equality and they should be equal" do  
+        expect(auction_state[:state_root_hash]).to eql(client.chain_get_StateRootHash)
+      end
+
+      it "checks that era_validators is not empty" do
+        expect(auction_state[:era_validators]).not_to be_empty
+      end
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,100 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # 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
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/spec/string_spec.rb

@@ -0,0 +1,68 @@
+require_relative '../lib/types/cl_string.rb'
+require_relative '../lib/types/constants.rb'
+require_relative '../lib/serialization/cl_value_bytes_parsers.rb'
+require 'json'
+
+=begin
+Strings serialize as a 32-bit integer representing the length in bytes 
+(note: this might be different than the number of characters since special characters, such as emojis, take more than one byte), 
+followed by the UTF-8 encoding of the characters in the string.
+E.g. "Hello, World!" serializes as 0x0d00000048656c6c6f2c20576f726c6421
+=end
+describe CLString do  
+  cl_string = CLString.new("ABC")
+  describe "#get_value" do
+    it "should return proper value" do  
+      expect(cl_string.get_value).to eq("ABC")
+    end
+  end
+
+  describe "#get_cl_type" do  
+    it "should return proper cl_type" do 
+      expect(cl_string.get_cl_type).to be_an_instance_of(String)
+    end
+  end
+
+  describe "#get_cl_type" do  
+    it "should return String type" do 
+      expect(cl_string.get_cl_type).to eq('String')
+    end
+  end
+
+  describe "#cl_string.get_size" do 
+    it "should return proper string length" do 
+      expect(cl_string.get_size).to eq(3)
+    end
+  end
+
+  it "should return \'ABC\'" do  
+    expect(cl_string.from_bytes("03000000414243")).to eql("ABC")
+  end
+
+  it "should do to_bytes / from_bytes string serialization" do
+    string = CLString.new("Hello, World!")
+    value = string.get_value
+    bytes = string.to_bytes(value)
+    result_string = string.from_bytes(bytes)
+    puts value, bytes, result_string
+    expect(value).to eql("Hello, World!")
+    expect(bytes).to eql("0d00000048656c6c6f2c20576f726c6421")
+    expect(value).to eql(result_string)
+  end
+  it "to_bytes / from_bytes" do
+    str = "pclphXwfYmCmdITj8hnh"
+    len = str.length
+    hex1 = len.to_s(16).rjust(8, '0').scan(/../).reverse.join('')
+    hex2 = str.unpack("H*").first
+    hex3 = hex1 + hex2
+    expected_hex1 = "14000000"
+    expected_hex2 = "70636c7068587766596d436d6449546a38686e68"
+    expected_hex3 = "1400000070636c7068587766596d436d6449546a38686e68"
+    puts str
+    puts hex3
+    puts CLValueBytesParsers::CLStringBytesParser.to_bytes(str)
+    puts CLValueBytesParsers::CLStringBytesParser.from_bytes(hex3)
+  end
+end
+
+