Homework 3 tests

03-test.rb

describe RBFS do
  describe 'Directory' do
    subject(:directory) { RBFS::Directory.new }

    context 'with files and directories' do
      let(:readme) { RBFS::File.new('Hello world!')  }
      let(:spec)   { RBFS::File.new('describe RBFS') }

      before(:each) do
        directory.add_file('README',  readme)
        directory.add_file('spec.rb', spec)
      end

      it 'returns correct file hash' do
        expect(directory.files).to eq({'README' => readme, 'spec.rb' => spec})
      end
    end

    context 'serialization' do
      let(:simple_serialized_string) do
        [
          '2:',
            'README:19:string:Hello world!',
            'spec.rb:20:string:describe RBFS',
          '1:',
            'rbfs:4:',
              '0:',
              '0:',
        ].join ''
      end

      describe 'serialize with two files' do
        it 'can serialize' do
          directory.add_file 'README',  RBFS::File.new('Hello world!')
          directory.add_file 'spec.rb', RBFS::File.new('describe RBFS')
          directory.add_directory 'rbfs'

          expect(directory.serialize).to eq simple_serialized_string
        end
      end
     describe 'serialize with directory and bool file' do
        it 'can serialize' do
          directory.add_file 'bool',  RBFS::File.new(true)

          expect(directory.serialize).to eq '1:bool:12:boolean:true0:'

        end
      end


      let(:serialized_string) do
        [
	  '0:',
	  '1:',
	    'directory1:40:',
	      '0:',
	      '1:',
		'directory2:22:',
  		  '1:',
		    'README:9:number:42',
                  '0:',
        ].join ''
      end

      describe 'serialize with two sub directories' do
	it 'can serialize' do
	  directory.add_directory 'directory1', RBFS::Directory.new()
	  directory['directory1'].add_directory 'directory2', RBFS::Directory.new()
          directory['directory1']['directory2'].add_file 'README', RBFS::File.new(42)

	  expect(directory.serialize).to eq serialized_string  
	end
      end

      let(:serialized_string_multiple_files_dirs) do
        [
          '0:',
          '1:',
            'directory1:88:',
              '0:',
              '2:',
                'directory2:22:',
                  '1:',
                    'README:9:number:42',
                  '0:',
		'directory3:34:',
		  '0:',
		  '1:',
		    'lastDir:19:',
		      '1:',
			'lastFile:4:nil:',
		      '0:',
        ].join ''
      end

      describe 'serialize with multiple subs dirs and files' do
	it 'can serialize' do
	  directory.add_directory 'directory1', RBFS::Directory.new()
          directory['directory1'].add_directory 'directory2', RBFS::Directory.new()
          directory['directory1']['directory2'].add_file 'README', RBFS::File.new(42)
          directory['directory1'].add_directory 'directory3', RBFS::Directory.new()
	  directory['directory1']['directory3'].add_directory 'lastDir', RBFS::Directory.new()
          directory['directory1']['directory3']['lastDir'].add_file 'lastFile', RBFS::File.new()

	  expect(directory.serialize).to eq serialized_string_multiple_files_dirs
        end
      end

      describe '::parse' do
        it 'can parse' do
          parsed_directory = RBFS::Directory.parse(simple_serialized_string)

          expect(parsed_directory.files.size     ).to eq    2
          expect(parsed_directory['README'].data ).to eq    'Hello world!'
          expect(parsed_directory['spec.rb'].data).to eq    'describe RBFS'
          expect(parsed_directory['rbfs']        ).to be_an RBFS::Directory
        end
      end
    end

    it 'can add a file' do
      file = RBFS::File.new('Hey there!')

      directory.add_file 'README', file

      expect(directory.files).to eq({'README' => file})
    end

    it 'can add a directory' do
      subdirectory = RBFS::Directory.new

      directory.add_directory 'home', subdirectory

      expect(directory.directories).to eq({'home' => subdirectory})
    end

    describe '#[]' do
      let(:home) { RBFS::Directory.new }

      before(:each) do
        directory.add_directory 'home', home
      end

      it 'can walk a directory' do
        expect(directory['home']).to eq home
      end

      it 'cannot access missing folder' do
        expect(directory['wrongFolderName']).to eq nil
      end
    end
  end

  describe 'File' do
    subject(:file) { RBFS::File.new }

    it 'can store data' do
      file.data = 'hello world'
      expect(file.data).to eq 'hello world'
    end

    it 'can accept data in the initializer' do
      file = RBFS::File.new('Hay :)')

      expect(file.data).to eq 'Hay :)'
    end
  end

  context 'data type' do
    it 'number' do
      expect(RBFS::File.new(42).data_type).to eq :number
    end

    it 'nil' do
      expect(RBFS::File.new().data_type).to eq :nil
    end

    it 'string' do
      expect(RBFS::File.new('string').data_type).to eq :string
    end

    it 'symbol' do
      expect(RBFS::File.new(:s).data_type).to eq :symbol
    end

    it 'bool' do
        expect(RBFS::File.new(false).data_type).to eq :boolean
        expect(RBFS::File.new(true).data_type).to  eq :boolean
    end
  end

  context 'serialization' do
    it 'sample serialization' do
      file = RBFS::File.new('Hay :)')

      expect(file.serialize).to eq 'string:Hay :)'
    end

    it 'empty file == nil' do
      file = RBFS::File.new()

      expect(file.serialize).to eq 'nil:'
    end

    it 'symbol' do
      file = RBFS::File.new(:yo)

      expect(file.serialize).to eq 'symbol:yo'
    end

    it 'number' do
      file = RBFS::File.new(42.123)

      expect(file.serialize).to eq 'number:42.123'
    end

    it 'boolean' do
      file = RBFS::File.new(true)

      expect(file.serialize).to eq 'boolean:true'
    end
  end

  context 'parsing' do
    it 'boolean' do
      expect(RBFS::File.parse('boolean:true').data_type).to  eq :boolean
      expect(RBFS::File.parse('boolean:true').data).to       eq true
      expect(RBFS::File.parse('boolean:false').data_type).to eq :boolean
      expect(RBFS::File.parse('boolean:false').data).to      eq false
    end

    it 'float number' do
      expect(RBFS::File.parse('number:42.123').data_type).to eq :number
      expect(RBFS::File.parse('number:42.123').data).to      eq 42.123
    end

    it 'integer number' do
      expect(RBFS::File.parse('number:42').data_type).to eq :number
      expect(RBFS::File.parse('number:42').data).to      eq 42
    end
  end
end