Esempio n. 1
0
func TestSearchCompactParseCompact(t *testing.T) {
	body := ioutil.NopCloser(strings.NewReader(compactDecoded))

	cr, err := NewCompactSearchResult(body)
	testutils.Ok(t, err)

	testutils.Assert(t, StatusOK == cr.Response.Code, "bad code")
	testutils.Assert(t, "V2.7.0 2315: Success" == cr.Response.Text, "bad text")

	testutils.Assert(t, 10 == int(cr.Count), "bad count")
	testutils.Assert(t, 6 == len(cr.Columns), "bad header count")

	testutils.Assert(t, "A,B,C,D,E,F" == strings.Join(cr.Columns, ","), "bad headers")

	counter := 0
	maxRows, err := cr.ForEach(func(row Row, err error) error {
		if strings.Join(row, ",") != "1,2,3,4,,6" {
			t.Errorf("bad row %d: %s", counter, row)
		}

		if err != nil {
			t.Errorf("error parsing body at row %d: %s", counter, err.Error())
		}
		counter = counter + 1
		return nil
	})
	testutils.Ok(t, err)

	testutils.Assert(t, 8 == counter, "bad count")
	testutils.Assert(t, maxRows, "bad max rows")

}
Esempio n. 2
0
func TestSearchXMLComplex(t *testing.T) {
	type Listing struct {
		Business      string  `xml:"Business>RESIOWNS"`
		Approved      bool    `xml:"Listing>Approved"`
		MLS           string  `xml:"Listing>MLS"`
		Disclaimer    string  `xml:"Listing>Disclaimer"`
		Status        string  `xml:"Listing>Status"`
		ListingPrice  float64 `xml:"Listing>Price>ListingPrice"`
		OriginalPrice float64 `xml:"Listing>Price>OriginalPrice"`
		SellPrice     float64 `xml:"Listing>Price>SellingPrice"`
	}
	body := ioutil.NopCloser(strings.NewReader(standardXML))

	cr, err := NewStandardXMLSearchResult(body)
	testutils.Ok(t, err)

	var listings []Listing
	count, maxRows, err := cr.ForEach(minidom.ByName("PropertyListing"), func(elem io.ReadCloser, err error) error {
		if err != nil {
			return err
		}
		listing := Listing{}
		xml.NewDecoder(elem).Decode(&listing)
		listings = append(listings, listing)
		return err
	})
	testutils.Ok(t, err)
	testutils.Equals(t, true, maxRows)
	testutils.Equals(t, 10, count)
	testutils.Equals(t, 2, len(listings))
}
func TestConvertCompactMetadata(t *testing.T) {
	body := ioutil.NopCloser(strings.NewReader(retsStart + system + resource + class + table + lookup + lookupType + retsEnd))
	compact, err := rets.ParseMetadataCompactResult(body)
	testutils.Ok(t, err)

	msystem, err := AsStandard(*compact).Convert()
	testutils.Ok(t, err)

	testutils.Equals(t, "MLS System", msystem.System.Description)
	testutils.Equals(t, "1.12.30", string(msystem.Version))
	testutils.Equals(t, "The System is provided to you by Systems.", msystem.System.Comments)

	mresource := msystem.System.MResource
	testutils.Equals(t, "1.12.30", string(mresource.Version))
	testutils.Equals(t, 2, len(mresource.Resource))

	mlookup := mresource.Resource[1].MLookup
	testutils.Equals(t, "1.12.29", string(mlookup.Version))
	testutils.Equals(t, 4, len(mlookup.Lookup))

	mlookupType := mlookup.Lookup[0].MLookupType
	testutils.Equals(t, "1.12.29", string(mlookupType.Version))
	testutils.Equals(t, 4, len(mlookupType.LookupType))

	agent := mresource.Resource[1]
	testutils.Equals(t, 2, len(agent.MClass.Class))
	testutils.Equals(t, "Agent", string(agent.ResourceID))
	testutils.Equals(t, "1.12.29", string(agent.MClass.Version))

}
Esempio n. 4
0
func TestParseCompactData(t *testing.T) {
	body := ioutil.NopCloser(strings.NewReader(compact))
	decoder := DefaultXMLDecoder(body, false)
	token, err := decoder.Token()
	testutils.Ok(t, err)
	start, ok := token.(xml.StartElement)
	testutils.Assert(t, ok, "should be a start element")
	testutils.Equals(t, "METADATA-ELEMENT", start.Name.Local)
	cm, err := NewCompactData(start, decoder, "	")
	testutils.Ok(t, err)
	testutils.Equals(t, "METADATA-ELEMENT", cm.Element)
	testutils.Equals(t, "Dog", cm.Attr["Cat"])
	testutils.Equals(t, 2, len(cm.CompactRows))
	testutils.Equals(t, 2, len(cm.Columns()))
}
Esempio n. 5
0
func TestSimple(t *testing.T) {
	doms := ioutil.NopCloser(strings.NewReader(example))
	parser := xml.NewDecoder(doms)
	listings := Listings{}
	// minidom isnt necessary but its crazy useful for massive streams
	md := minidom.MiniDom{
		StartFunc: func(start xml.StartElement) {
			switch start.Name.Local {
			case "Listings":
				attrs := map[string]string{}
				for _, v := range start.Attr {
					attrs[v.Name.Local] = v.Value
				}
				listings.ListingsKey = attrs["listingsKey"]
				listings.Version = attrs["version"]
				listings.VersionTimestamp = attrs["versionTimestamp"]
				listings.Language = attrs["lang"]
			case "Disclaimer":
				parser.DecodeElement(listings.Disclaimer, &start)
			}
		},
		// quit on the the xml tag
		EndFunc: minidom.QuitAt("Listings"),
	}
	err := md.Walk(parser, minidom.ByName("Listing"), ToListing(func(l Listing, err error) error {
		listings.Listings = append(listings.Listings, l)
		return err
	}))
	testutils.Ok(t, err)
	testutils.Equals(t, 1, len(listings.Listings))
	testutils.Equals(t, "http://www.somemls.com/lisings/1234567890", listings.Listings[0].ListingURL)
	testutils.Equals(t, "New Light Fixtures", *listings.Listings[0].Photos[1].Caption)
	testutils.Equals(t, "1100.0", listings.Listings[0].Expenses[2].Value.Value)
}
Esempio n. 6
0
func TestParseClass(t *testing.T) {
	body := ioutil.NopCloser(strings.NewReader(retsStart + class + retsEnd))

	ms, err := ParseMetadataCompactResult(body)
	testutils.Ok(t, err)
	verifyParseClass(t, *ms)
}
Esempio n. 7
0
func TestSearchXML(t *testing.T) {
	body := ioutil.NopCloser(strings.NewReader(standardXML))

	cr, err := NewStandardXMLSearchResult(body)
	testutils.Ok(t, err)

	var listings []io.ReadCloser
	count, maxRows, err := cr.ForEach(minidom.ByName("PropertyListing"), func(elem io.ReadCloser, err error) error {
		listings = append(listings, elem)
		return err
	})
	testutils.Ok(t, err)
	testutils.Equals(t, true, maxRows)
	testutils.Equals(t, 10, count)
	testutils.Equals(t, 2, len(listings))
}
Esempio n. 8
0
func TestSearchCompactNoEof(t *testing.T) {
	rets := `<RETS ReplyCode="20201" ReplyText="No Records Found." ></RETS>`
	body := ioutil.NopCloser(strings.NewReader(rets))

	cr, err := NewCompactSearchResult(body)
	testutils.Ok(t, err)
	testutils.Equals(t, StatusNoRecords, cr.Response.Code)
}
Esempio n. 9
0
func TestSystem(t *testing.T) {
	body := ioutil.NopCloser(strings.NewReader(raw))
	defer body.Close()

	extractor := &Extractor{Body: body}
	response, err := extractor.Open()

	testutils.Ok(t, err)
	testutils.Equals(t, "Operation Successful", response.ReplyText)

	xml := MSystem{}
	err = extractor.DecodeNext("METADATA-SYSTEM", &xml)
	if err != io.EOF {
		testutils.Ok(t, err)
	}
	testutils.Equals(t, "ABBA", xml.System.ID)
	testutils.Equals(t, "Property", string(xml.System.MResource.Resource[0].ResourceID))
}
Esempio n. 10
0
func TestCompactEntry(t *testing.T) {
	body := ioutil.NopCloser(strings.NewReader(compact))
	decoder := DefaultXMLDecoder(body, false)
	token, err := decoder.Token()
	testutils.Ok(t, err)
	start, ok := token.(xml.StartElement)
	testutils.Assert(t, ok, "should be a start element")
	cm, err := NewCompactData(start, decoder, "	")
	testutils.Ok(t, err)
	type Test struct {
		ResourceID, Standardname string
	}
	row1 := Test{}
	maps := cm.Entries()
	maps[0].SetFields(&row1)
	testutils.Equals(t, "ActiveAgent", row1.ResourceID)
	testutils.Equals(t, "ActiveAgent", row1.Standardname)
}
Esempio n. 11
0
func TestSearchCompactEmbeddedRetsStatus(t *testing.T) {
	rets := `<?xml version="1.0" encoding="UTF-8" ?>
			<RETS ReplyCode="0" ReplyText="Operation Successful">
			<RETS-STATUS ReplyCode="20201" ReplyText="No matching records were found" />
			</RETS>`
	body := ioutil.NopCloser(strings.NewReader(rets))
	cr, err := NewCompactSearchResult(body)
	testutils.Ok(t, err)
	testutils.Equals(t, StatusNoRecords, cr.Response.Code)
}
Esempio n. 12
0
func TestParseMetadata(t *testing.T) {
	body := ioutil.NopCloser(strings.NewReader(retsStart + system + resource + class + table + lookup + lookupType + retsEnd))
	ms, err := ParseMetadataCompactResult(body)
	testutils.Ok(t, err)

	verifySystem(t, *ms)
	verifyParseResources(t, *ms)
	verifyParseClass(t, *ms)
	verifyParseTable(t, *ms)
	verifyParseLookup(t, *ms)
	verifyParseLookupType(t, *ms)
}
Esempio n. 13
0
func TestNext(t *testing.T) {
	var raw = `<?xml version="1.0" encoding="utf-8"?>
    <RETS ReplyCode="0" ReplyText="Operation successful.">
    <METADATA>
    <METADATA-CLASS Version="01.72.11582" Date="2016-03-29T21:50:11" Resource="Agent">
    </METADATA-CLASS>
    <METADATA-CLASS Version="01.72.11583" Date="2016-03-29T21:50:11" Resource="Office">
    </METADATA-CLASS>
    <METADATA-CLASS Version="01.72.11584" Date="2016-03-29T21:50:11" Resource="Listing">
    </METADATA-CLASS>
    </METADATA>
    </RETS>`
	body := ioutil.NopCloser(strings.NewReader(raw))
	defer body.Close()

	extractor := &Extractor{Body: body}
	response, err := extractor.Open()

	testutils.Ok(t, err)
	testutils.Equals(t, "Operation successful.", response.ReplyText)

	next := func(resource, version, date string) func(*testing.T) {
		return func(tt *testing.T) {
			mclass := &MClass{}
			err = extractor.DecodeNext("METADATA-CLASS", mclass)
			testutils.Ok(t, err)
			testutils.Equals(tt, resource, string(mclass.Resource))
			testutils.Equals(tt, version, string(mclass.Version))
			testutils.Equals(tt, date, string(mclass.Date))
			testutils.Equals(tt, 0, len(mclass.Class))
		}
	}

	t.Run("agent", next("Agent", "01.72.11582", "2016-03-29T21:50:11"))
	t.Run("offfice", next("Office", "01.72.11583", "2016-03-29T21:50:11"))
	t.Run("listing", next("Listing", "01.72.11584", "2016-03-29T21:50:11"))

	err = extractor.DecodeNext("METADATA-CLASS", &MClass{})
	testutils.Equals(t, io.EOF, err)
}
Esempio n. 14
0
func TestSearchCompactBadChar(t *testing.T) {
	rets := `<?xml version="1.0" encoding="UTF-8" ?>
			<RETS ReplyCode="0" ReplyText="Operation Successful">
			<COUNT Records="1" />
			<DELIMITER value = "09"/>
			<COLUMNS>	A	B	C	D	E	F	</COLUMNS>
			<DATA>	1` + "\x0b" + `1	2	3	4		6	</DATA>

			</RETS>`
	body := ioutil.NopCloser(strings.NewReader(rets))

	cr, err := NewCompactSearchResult(body)
	testutils.Ok(t, err)
	testutils.Equals(t, StatusOK, cr.Response.Code)
	counter := 0
	cr.ForEach(func(row Row, err error) error {
		testutils.Ok(t, err)
		testutils.Equals(t, "1 1,2,3,4,,6", strings.Join(row, ","))
		counter = counter + 1
		return nil
	})
}
Esempio n. 15
0
func TestSearchXMLBadChar(t *testing.T) {
	type Listing struct {
		Row string
	}
	rets := `<?xml version="1.0" encoding="UTF-8" ?>
			<RETS ReplyCode="0" ReplyText="Operation Successful">
			<COUNT Records="5" />
			<Listings>
			<PropertyListing>
				<Row>bad` + "\x0b" + `row</Row>
			</PropertyListing>
			<PropertyListing>
				<Row>good row</Row>
			</PropertyListing>
			</Listings>
			<MAXROWS/>
			</RETS>`
	body := ioutil.NopCloser(strings.NewReader(rets))

	cr, err := NewStandardXMLSearchResult(body)
	testutils.Ok(t, err)
	testutils.Equals(t, StatusOK, cr.Response.Code)
	var listings []Listing
	count, maxRows, err := cr.ForEach(minidom.ByName("PropertyListing"), func(elem io.ReadCloser, err error) error {
		listing := Listing{}
		xml.NewDecoder(elem).Decode(&listing)
		listings = append(listings, listing)
		return err
	})
	testutils.Ok(t, err)
	testutils.Equals(t, true, maxRows)
	testutils.Equals(t, 5, count)
	testutils.Equals(t, 2, len(listings))
	testutils.Equals(t, "bad row", listings[0].Row)
	testutils.Equals(t, "good row", listings[1].Row)
}
Esempio n. 16
0
func TestLoad(t *testing.T) {
	body := ioutil.NopCloser(strings.NewReader(raw))
	defer body.Close()
	parser := xml.NewDecoder(body)
	xml := RETSResponseWrapper{}

	err := parser.Decode(&xml)
	if err != io.EOF {
		testutils.Ok(t, err)
	}
	testutils.Equals(t, "Operation Successful", xml.ReplyText)

	testutils.Equals(t, "ABBA", xml.Metadata.MSystem.System.ID)
	testutils.Equals(t, "Property", string(xml.Metadata.MSystem.System.MResource.Resource[0].ResourceID))
}
Esempio n. 17
0
func TestSearchXMLParseSearchQuit(t *testing.T) {
	noEnd := strings.Split(standardXML, "Commercial")[0]
	body := ioutil.NopCloser(strings.NewReader(noEnd))

	cr, err := NewStandardXMLSearchResult(body)
	testutils.Ok(t, err)

	var listings [][]byte
	count, maxRows, err := cr.ForEach(minidom.ByName("PropertyListing"), func(elem io.ReadCloser, err error) error {
		tmp, _ := ioutil.ReadAll(elem)
		listings = append(listings, tmp)
		return err
	})
	testutils.NotOk(t, err)
	testutils.Equals(t, false, maxRows)
	testutils.Equals(t, 10, count)
	testutils.Equals(t, 1, len(listings))
}
Esempio n. 18
0
func TestSearchCompactParseSearchQuit(t *testing.T) {
	noEnd := strings.Split(compactDecoded, "<MAXROWS/>")[0]
	body := ioutil.NopCloser(strings.NewReader(noEnd))

	cr, err := NewCompactSearchResult(body)
	testutils.Ok(t, err)

	rowsFound := 0
	cr.ForEach(func(data Row, err error) error {
		if err != nil {
			testutils.Assert(t, strings.Contains(err.Error(), "EOF"), "found something not eof")
			return err
		}
		testutils.Equals(t, "1,2,3,4,,6", strings.Join(data, ","))
		rowsFound++
		return nil
	})
	testutils.Equals(t, 8, rowsFound)
}
Esempio n. 19
0
func TestGetObject(t *testing.T) {
	header := http.Header{}
	textproto.MIMEHeader(header).Add("Content-Type", "image/jpeg")
	textproto.MIMEHeader(header).Add("Content-ID", "123456")
	textproto.MIMEHeader(header).Add("Object-ID", "1")
	textproto.MIMEHeader(header).Add("Preferred", "1")
	textproto.MIMEHeader(header).Add("UID", "1a234234234")
	textproto.MIMEHeader(header).Add("Content-Description", "Outhouse")
	textproto.MIMEHeader(header).Add("Content-Sub-Description", "The urinal")
	textproto.MIMEHeader(header).Add("Location", "http://www.simpleboundary.com/image-5.jpg")

	var body = `<binary data 1>`

	response := GetObjectResponse{
		response: &http.Response{
			Header: header,
			Body:   ioutil.NopCloser(strings.NewReader(body)),
		},
	}
	defer response.Close()
	var objects []*Object
	err := response.ForEach(func(o *Object, err error) error {
		objects = append(objects, o)
		return nil
	})
	testutils.Ok(t, err)

	testutils.Equals(t, 1, len(objects))

	o := objects[0]
	testutils.Equals(t, true, o.Preferred)
	testutils.Equals(t, "image/jpeg", o.ContentType)
	testutils.Equals(t, "123456", o.ContentID)
	testutils.Equals(t, 1, o.ObjectID)
	testutils.Equals(t, "1a234234234", o.UID)
	testutils.Equals(t, "Outhouse", o.Description)
	testutils.Equals(t, "The urinal", o.SubDescription)
	testutils.Equals(t, "<binary data 1>", string(o.Blob))
	testutils.Equals(t, "http://www.simpleboundary.com/image-5.jpg", o.Location)
	testutils.Equals(t, false, o.RetsError)
}
Esempio n. 20
0
func TestParseCapabilitiesRelativeUrls(t *testing.T) {
	body :=
		`<RETS ReplyCode="0" ReplyText="V2.7.0 2315: Success">
	<RETS-RESPONSE>
	MemberName=Threewide Corporation
	User=2000343, Association Member Primary:Login:Media Restrictions:Office:RETS:RETS Advanced:RETS Customer:System-MRIS:MDS Access Common:MDS Application Login, 90, TURD1
	Broker=TWD,1
	MetadataVersion=1.12.30
	MinMetadataVersion=1.1.1
	OfficeList=TWD;1
	TimeoutSeconds=1800
	Login=/platinum/login
	Action=/platinum/get?Command=Message
	Search=/platinum/search
	Get=/platinum/get
	GetObject=/platinum/getobject
	Logout=/platinum/logout
	GetMetadata=/platinum/getmetadata
	ChangePassword=/platinum/changepassword
	X-SampleLinks=/rets2_2/Links
	X-SupportSite=http://flexmls.com/rets/
	X-NotificationFeed=http://example.com/atom/feed/private/atom.xml
	</RETS-RESPONSE>
	</RETS>`
	urls, err := parseCapability(
		ioutil.NopCloser(strings.NewReader(body)),
		"http://server.com:6103/platinum/login",
	)
	testutils.Ok(t, err)

	testutils.Equals(t, urls.Response.Text, "V2.7.0 2315: Success")
	testutils.Equals(t, urls.Response.Code, StatusOK)
	testutils.Equals(t, urls.Login, "http://server.com:6103/platinum/login")
	testutils.Equals(t, urls.GetMetadata, "http://server.com:6103/platinum/getmetadata")
	testutils.Equals(t, "http://server.com:6103/rets2_2/Links", urls.AdditionalURLs["X-SampleLinks"])
}
Esempio n. 21
0
func TestClass(t *testing.T) {
	var raw = `<?xml version="1.0" encoding="utf-8"?>
    <RETS ReplyCode="0" ReplyText="Operation Successful">
    <METADATA>
    <METADATA-CLASS Version="01.72.11588" Date="2016-06-01T16:05:01" Resource="Property">
      <Class>
        <ClassName>COMM</ClassName>
        <StandardName>CommercialSale</StandardName>
        <VisibleName>Commercial</VisibleName>
        <Description>Contains data for Commercial searches.</Description>
        <TableVersion>01.72.11581</TableVersion>
        <TableDate>2016-02-09T06:02:17</TableDate>
        <UpdateVersion>01.72.10221</UpdateVersion>
        <UpdateDate/>
        <ClassTimeStamp>LastModifiedDateTime</ClassTimeStamp>
        <DeletedFlagField/>
        <DeletedFlagValue/>
        <HasKeyIndex>0</HasKeyIndex>
        <ColumnGroupVersion>01.72.11581</ColumnGroupVersion>
        <ColumnGroupDate>2016-02-09T06:02:17</ColumnGroupDate>
        <ColumnGroupSetVersion>01.72.11581</ColumnGroupSetVersion>
        <ColumnGroupSetDate>2016-02-09T06:02:17</ColumnGroupSetDate>
        <METADATA-TABLE Version="01.72.11581" Date="2016-02-09T06:02:17" System="ANNA" Resource="Property" Class="COMM">
        </METADATA-TABLE>
      </Class>
      <Class>
          <ClassName>LOTL</ClassName>
          <StandardName>Land</StandardName>
      </Class>
      </METADATA-CLASS>
    </METADATA>
    </RETS>`

	body := ioutil.NopCloser(strings.NewReader(raw))
	defer body.Close()

	extractor := &Extractor{Body: body}
	response, err := extractor.Open()

	testutils.Ok(t, err)
	testutils.Equals(t, "Operation Successful", response.ReplyText)

	mclass := &MClass{}
	err = extractor.DecodeNext("METADATA-CLASS", mclass)
	testutils.Ok(t, err)
	testutils.Equals(t, "Property", string(mclass.Resource))
	testutils.Equals(t, "01.72.11588", string(mclass.Version))
	testutils.Equals(t, "2016-06-01T16:05:01", string(mclass.Date))
	testutils.Equals(t, 2, len(mclass.Class))

	comm := mclass.Class[0]
	testutils.Equals(t, "COMM", string(comm.ClassName))
	testutils.Equals(t, "CommercialSale", string(comm.StandardName))
	testutils.Equals(t, "Commercial", string(comm.VisibleName))
	testutils.Equals(t, "Contains data for Commercial searches.", string(comm.Description))
	testutils.Equals(t, "01.72.11581", string(comm.TableVersion))
	testutils.Equals(t, "2016-02-09T06:02:17", string(comm.TableDate))
	// TODO fill in the rest when time permits

	lotl := mclass.Class[1]
	testutils.Equals(t, "LOTL", string(lotl.ClassName))
	testutils.Equals(t, "Land", string(lotl.StandardName))
}
Esempio n. 22
0
func TestGetObjects(t *testing.T) {
	headers := http.Header{}
	headers.Add("Content-Type", contentType)
	response := GetObjectResponse{
		response: &http.Response{
			Header: headers,
			Body:   ioutil.NopCloser(strings.NewReader(multipartBody)),
		},
	}
	defer response.Close()
	var objects []*Object
	response.ForEach(func(o *Object, err error) error {
		testutils.Ok(t, err)
		objects = append(objects, o)
		return nil
	})

	o1 := objects[0]
	testutils.Equals(t, true, o1.Preferred)
	testutils.Equals(t, "image/jpeg", o1.ContentType)
	testutils.Equals(t, "123456", o1.ContentID)
	testutils.Equals(t, 1, o1.ObjectID)
	testutils.Equals(t, "<binary data 1>", string(o1.Blob))
	testutils.Equals(t, "123456", o1.ObjectData["ListingKey"])
	testutils.Equals(t, "2013-05-01T12:34:34.8-0500", o1.ObjectData["ListDate"])

	o2 := objects[1]
	testutils.Equals(t, 2, o2.ObjectID)
	testutils.Equals(t, "1a234234234", o2.UID)

	o3 := objects[2]
	testutils.Equals(t, 3, o3.ObjectID)
	testutils.Equals(t, "Outhouse", o3.Description)
	testutils.Equals(t, "The urinal", o3.SubDescription)

	o4 := objects[3]
	testutils.Equals(t, true, o4.RetsError)

	testutils.Equals(t, "text/xml", o4.ContentType)
	testutils.Equals(t, "There is no object with that Object-ID", o4.RetsMessage.Text)
	testutils.Equals(t, StatusObjectNotFound, o4.RetsMessage.Code)

	o5 := objects[4]
	testutils.Equals(t, "http://www.simpleboundary.com/image-5.jpg", o5.Location)
	testutils.Equals(t, "image/jpeg", o5.ContentType)
	testutils.Equals(t, "123457", o5.ContentID)
	testutils.Equals(t, 5, o5.ObjectID)
	testutils.Equals(t, "", string(o5.Blob))

	o6 := objects[5]
	testutils.Equals(t, "http://www.simpleboundary.com/image-6.jpg", o6.Location)
	testutils.Equals(t, "image/jpeg", o6.ContentType)
	testutils.Equals(t, "123457", o6.ContentID)
	testutils.Equals(t, 6, o6.ObjectID)
	testutils.Equals(t, "<binary data 6>", string(o6.Blob))
	testutils.Assert(t, o6.RetsMessage == nil, "should not be the zerod object")

	o7 := objects[6]
	testutils.Equals(t, "http://www.simpleboundary.com/image-7.jpg", o7.Location)
	testutils.Equals(t, "image/jpeg", o7.ContentType)
	testutils.Equals(t, "123457", o7.ContentID)
	testutils.Equals(t, 7, o7.ObjectID)
	testutils.Equals(t, "", string(o7.Blob))
	testutils.Equals(t, "Found it!", o7.RetsMessage.Text)

}