Golang NewStringField Examples

Example #1

File: session_test.go Project: jarlwolfganger/quickfix

func TestSession_CheckBeginString(t *testing.T) {
	session := Session{
		sessionID: SessionID{BeginString: "FIX.4.2"},
	}

	builder := getBuilder()

	//wrong value
	builder.Header().Set(fix.NewStringField(tag.BeginString, "FIX.4.4"))
	msgBytes, _ := builder.Build()
	msg, _ := parseMessage(msgBytes)

	err := session.checkBeginString(*msg)
	if err == nil {
		t.Error("Expected Error")
	}
	_ = err.(incorrectBeginString)

	builder.Header().Set(fix.NewStringField(tag.BeginString, session.sessionID.BeginString))
	msgBytes, _ = builder.Build()
	msg, _ = parseMessage(msgBytes)

	err = session.checkBeginString(*msg)

	if err != nil {
		t.Error("Unexpected error", err)
	}
}

Example #2

File: validation_test.go Project: jarlwolfganger/quickfix

func (s *ValidationTests) TestValidateInvalidTagNumber(c *C) {
	dict, _ := datadictionary.Parse("spec/FIX40.xml")

	builder := s.createFIX40NewOrderSingle()
	builder.Header().Set(fix.NewStringField(9999, "hello"))
	msgBytes, _ := builder.Build()
	msg, _ := parseMessage(msgBytes)
	reject := validate(dict, *msg)
	c.Check(reject, NotNil)
	c.Check(reject.RejectReason(), Equals, rejectReasonInvalidTagNumber)
	c.Check(*reject.RefTagID(), Equals, fix.Tag(9999))

	builder = s.createFIX40NewOrderSingle()
	builder.Trailer().Set(fix.NewStringField(9999, "hello"))
	msgBytes, _ = builder.Build()
	msg, _ = parseMessage(msgBytes)

	reject = validate(dict, *msg)
	c.Check(reject, NotNil)
	c.Check(reject.RejectReason(), Equals, rejectReasonInvalidTagNumber)
	c.Check(*reject.RefTagID(), Equals, fix.Tag(9999))

	builder = s.createFIX40NewOrderSingle()
	builder.Body().Set(fix.NewStringField(9999, "hello"))
	msgBytes, _ = builder.Build()
	msg, _ = parseMessage(msgBytes)

	reject = validate(dict, *msg)
	c.Check(reject, NotNil)
	c.Check(reject.RejectReason(), Equals, rejectReasonInvalidTagNumber)
	c.Check(*reject.RefTagID(), Equals, fix.Tag(9999))
}

Example #3

File: field_map_test.go Project: jarlwolfganger/quickfix

func TestFieldMap_Total(t *testing.T) {
	f1 := fix.NewStringField(1, "hello")
	f2 := fix.NewStringField(2, "world")

	beginString := fix.NewStringField(8, "FIX.4.4")
	bodyLength := fix.NewIntField(9, 100)
	checkSum := fix.NewStringField(10, "100")

	fMap := fieldMap{}
	fMap.init(normalFieldOrder)
	fMap.Set(f1)
	fMap.Set(f2)
	fMap.Set(beginString)
	fMap.Set(bodyLength)
	fMap.Set(checkSum)

	if fMap.total() != 2116 {
		t.Error("Total should includes all fields but checkSum- got ", fMap.total())
	}
}

Example #4

File: validation_test.go Project: jarlwolfganger/quickfix

func (s *ValidationTests) TestValidateValueIsIncorrect(c *C) {
	dict, _ := datadictionary.Parse("spec/FIX40.xml")
	builder := s.createFIX40NewOrderSingle()
	builder.Body().Set(fix.NewStringField(tag.HandlInst, "4"))
	msgBytes, _ := builder.Build()
	msg, _ := parseMessage(msgBytes)

	reject := validate(dict, *msg)
	c.Check(reject, NotNil)
	c.Check(reject.RejectReason(), Equals, rejectReasonValueIsIncorrect)
	c.Check(*reject.RefTagID(), Equals, tag.HandlInst)
}

Example #5

File: message_builder_test.go Project: jmptrader/quickfix

func TestMessageBuilder_checkBuild(t *testing.T) {
	builder = NewMessageBuilder()

	builder.Header().Set(field.NewBeginString(fix.BeginString_FIX44))
	builder.Header().Set(fix.NewStringField(tag.MsgType, "A"))
	builder.Header().Set(fix.NewStringField(tag.SendingTime, "20140615-19:49:56"))

	builder.Body().Set(field.NewUsername("my_user"))
	builder.Body().Set(field.NewPassword("secret"))

	expectedBytes := []byte("8=FIX.4.4
9=49
35=A
52=20140615-19:49:56
553=my_user
554=secret
10=072
")
	result, err := builder.Build()
	if err != nil {
		t.Error("Unexpected error", err)
	}

	if !bytes.Equal(expectedBytes, result) {
		t.Error("Unexpected bytes, got ", string(result))
	}

}

Example #6

File: validation_test.go Project: jarlwolfganger/quickfix

func (s *ValidationTests) TestValidateIncorrectDataFormatForValue(c *C) {
	dict, _ := datadictionary.Parse("spec/FIX40.xml")
	builder := s.createFIX40NewOrderSingle()
	builder.Body().Set(fix.NewStringField(tag.OrderQty, "+200.00"))
	msgBytes, _ := builder.Build()
	msg, _ := parseMessage(msgBytes)

	reject := validate(dict, *msg)
	c.Check(reject, NotNil)
	c.Check(reject.RejectReason(), Equals, rejectReasonIncorrectDataFormatForValue)
	c.Check(*reject.RefTagID(), Equals, tag.OrderQty)
}

Example #7

File: validation_test.go Project: jarlwolfganger/quickfix

func (s *ValidationTests) TestValidateInvalidMsgType(c *C) {
	dict, _ := datadictionary.Parse("spec/FIX40.xml")

	builder := s.createFIX40NewOrderSingle()
	builder.Header().Set(fix.NewStringField(tag.MsgType, "z"))
	msgBytes, _ := builder.Build()
	msg, _ := parseMessage(msgBytes)

	reject := validate(dict, *msg)
	c.Check(reject, NotNil)
	c.Check(reject.RejectReason(), Equals, rejectReasonInvalidMsgType)
}

Example #8

File: validation_test.go Project: jarlwolfganger/quickfix

func (s *ValidationTests) TestValidateTagSpecifiedWithoutAValue(c *C) {
	dict, _ := datadictionary.Parse("spec/FIX40.xml")
	builder := s.createFIX40NewOrderSingle()
	builder.Body().Set(fix.NewStringField(tag.ClientID, ""))
	msgBytes, _ := builder.Build()
	msg, _ := parseMessage(msgBytes)

	reject := validate(dict, *msg)
	c.Check(reject, NotNil)
	c.Check(reject.RejectReason(), Equals, rejectReasonTagSpecifiedWithoutAValue)
	c.Check(*reject.RefTagID(), Equals, tag.ClientID)
}

Example #9

File: validation_test.go Project: jarlwolfganger/quickfix

func (s *ValidationTests) TestValidateTagNotDefinedForMessage(c *C) {
	dict, _ := datadictionary.Parse("spec/FIX40.xml")

	builder := s.createFIX40NewOrderSingle()
	builder.Body().Set(fix.NewStringField(41, "hello"))
	msgBytes, _ := builder.Build()
	msg, _ := parseMessage(msgBytes)

	reject := validate(dict, *msg)
	c.Check(reject, NotNil)
	c.Check(reject.RejectReason(), Equals, rejectReasonTagNotDefinedForThisMessageType)
	c.Check(*reject.RefTagID(), Equals, fix.Tag(41))
}

Example #10

File: validation_test.go Project: jarlwolfganger/quickfix

func (s *ValidationTests) TestValidateTagSpecifiedOutOfRequiredOrder(c *C) {
	dict, _ := datadictionary.Parse("spec/FIX40.xml")
	builder := s.createFIX40NewOrderSingle()
	//should be in header
	builder.Body().Set(fix.NewStringField(tag.OnBehalfOfCompID, "CWB"))
	msgBytes, _ := builder.Build()
	msg, _ := parseMessage(msgBytes)

	reject := validate(dict, *msg)
	c.Check(reject, NotNil)
	c.Check(reject.RejectReason(), Equals, rejectReasonTagSpecifiedOutOfRequiredOrder)
	c.Check(*reject.RefTagID(), Equals, tag.OnBehalfOfCompID)
}

Example #11

File: session.go Project: jarlwolfganger/quickfix

func (s *Session) resend(msg *Message) {
	header := msg.Header.(fieldMap)
	header.Set(field.NewPossDupFlag(true))

	origSendingTime := new(fix.StringValue)
	if err := header.GetField(tag.SendingTime, origSendingTime); err == nil {
		header.Set(fix.NewStringField(tag.OrigSendingTime, origSendingTime.Value))
	}

	s.insertSendingTime(header)

	msg.rebuild()
	s.sendBytes(msg.rawMessage)
}

Example #12

File: message_test.go Project: jarlwolfganger/quickfix

func TestMessage_rebuild(t *testing.T) {
	rawMsg := []byte("8=FIX.4.2
9=104
35=D
34=2
49=TW
52=20140515-19:49:56.659
56=ISLD
11=100
21=1
40=1
54=1
55=TSLA
60=00010101-00:00:00.000
10=039
")

	msg, _ := parseMessage(rawMsg)
	header := msg.Header.(fieldMap)

	header.Set(fix.NewStringField(tag.OrigSendingTime, "20140515-19:49:56.659"))
	header.Set(fix.NewStringField(tag.SendingTime, "20140615-19:49:56"))

	msg.rebuild()

	expectedBytes := []byte("8=FIX.4.2
9=126
35=D
34=2
49=TW
52=20140615-19:49:56
56=ISLD
122=20140515-19:49:56.659
11=100
21=1
40=1
54=1
55=TSLA
60=00010101-00:00:00.000
10=128
")

	if !bytes.Equal(expectedBytes, msg.rawMessage) {
		t.Error("Unexpected bytes, got ", string(msg.rawMessage))
	}

	expectedBodyBytes := []byte("11=100
21=1
40=1
54=1
55=TSLA
60=00010101-00:00:00.000
")

	if !bytes.Equal(msg.bodyBytes, expectedBodyBytes) {
		t.Error("Incorrect body bytes, got ", string(msg.bodyBytes))
	}
}

Example #13

File: field_map_test.go Project: jarlwolfganger/quickfix

func TestFieldMap_SetAndGet(t *testing.T) {
	fMap := fieldMap{}
	fMap.init(normalFieldOrder)

	fMap.Set(fix.NewStringField(1, "hello"))
	fMap.Set(fix.NewStringField(2, "world"))

	var testCases = []struct {
		tag         fix.Tag
		expectErr   bool
		expectValue string
	}{
		{tag: 1, expectValue: "hello"},
		{tag: 2, expectValue: "world"},
		{tag: 44, expectErr: true},
	}

	for _, tc := range testCases {
		testField := fix.NewStringField(tc.tag, "")
		err := fMap.Get(testField)

		if tc.expectErr {
			if err == nil {
				t.Error("Expected Error")
			}
			continue
		}

		if err != nil {
			t.Error("Unexpected Error", err)
		}

		if testField.Value != tc.expectValue {
			t.Errorf("Expected %v got %v", tc.expectValue, testField.Value)
		}
	}
}

Example #14

File: in_session.go Project: jarlwolfganger/quickfix

func (state *inSession) generateSequenceReset(session *Session, beginSeqNo int, endSeqNo int) {
	sequenceReset := NewMessageBuilder()
	session.fillDefaultHeader(sequenceReset)

	sequenceReset.Header().Set(field.NewMsgType("4"))
	sequenceReset.Header().Set(field.NewMsgSeqNum(beginSeqNo))
	sequenceReset.Header().Set(field.NewPossDupFlag(true))
	sequenceReset.Body().Set(field.NewNewSeqNo(endSeqNo))
	sequenceReset.Body().Set(field.NewGapFillFlag(true))

	origSendingTime := new(fix.StringValue)
	if err := sequenceReset.Header().GetField(tag.SendingTime, origSendingTime); err == nil {
		sequenceReset.Header().Set(fix.NewStringField(tag.OrigSendingTime, origSendingTime.Value))
	}

	//FIXME error check?
	msgBytes, _ := sequenceReset.Build()
	session.sendBytes(msgBytes)
}

Example #15

File: session_test.go Project: jarlwolfganger/quickfix

func getBuilder() MessageBuilder {
	builder := NewMessageBuilder()
	builder.Header().Set(fix.NewStringField(tag.BeginString, fix.BeginString_FIX40))
	builder.Header().Set(fix.NewStringField(tag.MsgType, "D"))
	return builder
}

Example #16

File: validation_test.go Project: jarlwolfganger/quickfix

func (s *ValidationTests) createFIX43NewOrderSingle() MessageBuilder {
	msg := NewMessageBuilder()
	msg.Header().Set(fix.NewStringField(tag.MsgType, "D"))
	msg.Header().Set(fix.NewStringField(tag.BeginString, "FIX.4.3"))
	msg.Header().Set(fix.NewStringField(tag.BodyLength, "0"))
	msg.Header().Set(fix.NewStringField(tag.SenderCompID, "0"))
	msg.Header().Set(fix.NewStringField(tag.TargetCompID, "0"))
	msg.Header().Set(fix.NewStringField(tag.MsgSeqNum, "0"))
	msg.Header().Set(fix.NewUTCTimestampField(tag.SendingTime, time.Now()))

	msg.Body().Set(fix.NewStringField(tag.ClOrdID, "A"))
	msg.Body().Set(fix.NewStringField(tag.HandlInst, "1"))
	msg.Body().Set(fix.NewStringField(tag.Symbol, "A"))
	msg.Body().Set(fix.NewStringField(tag.Side, "1"))
	msg.Body().Set(fix.NewIntField(tag.OrderQty, 5))
	msg.Body().Set(fix.NewStringField(tag.OrdType, "1"))
	msg.Body().Set(fix.NewUTCTimestampField(tag.TransactTime, time.Now()))

	msg.Trailer().Set(fix.NewStringField(tag.CheckSum, "000"))

	return msg
}

Example #17

File: message.go Project: jarlwolfganger/quickfix

func newCheckSum(value int) *fix.StringField {
	return fix.NewStringField(tag.CheckSum, fmt.Sprintf("%03d", value))
}

Example #18

File: validation_test.go Project: jarlwolfganger/quickfix

func (s *ValidationTests) TestValidateFieldNotFound(c *C) {
	dict, _ := datadictionary.Parse("spec/FIX40.xml")

	builder := NewMessageBuilder()
	builder.Header().Set(fix.NewStringField(tag.MsgType, "D"))
	builder.Header().Set(fix.NewStringField(tag.BeginString, "FIX.4.0"))
	builder.Header().Set(fix.NewStringField(tag.BodyLength, "0"))
	builder.Header().Set(fix.NewStringField(tag.SenderCompID, "0"))
	builder.Header().Set(fix.NewStringField(tag.TargetCompID, "0"))
	builder.Header().Set(fix.NewStringField(tag.MsgSeqNum, "0"))
	builder.Header().Set(fix.NewUTCTimestampField(tag.SendingTime, time.Now()))
	builder.Trailer().Set(fix.NewStringField(tag.CheckSum, "000"))

	builder.Body().Set(fix.NewStringField(tag.ClOrdID, "A"))
	builder.Body().Set(fix.NewStringField(tag.HandlInst, "A"))
	builder.Body().Set(fix.NewStringField(tag.Symbol, "A"))
	builder.Body().Set(fix.NewStringField(tag.Side, "A"))
	builder.Body().Set(fix.NewStringField(tag.OrderQty, "A"))

	//ord type is required
	//builder.Body().Set(fix.NewStringField(tag.OrdType, "A"))
	msgBytes, _ := builder.Build()
	msg, _ := parseMessage(msgBytes)

	reject := validate(dict, *msg)
	c.Check(reject, NotNil)
	c.Check(reject.RejectReason(), Equals, rejectReasonRequiredTagMissing)
	c.Check(*reject.RefTagID(), Equals, tag.OrdType)

	builder = NewMessageBuilder()
	builder.Trailer().Set(fix.NewStringField(tag.CheckSum, "000"))
	builder.Body().Set(fix.NewStringField(tag.ClOrdID, "A"))
	builder.Body().Set(fix.NewStringField(tag.HandlInst, "A"))
	builder.Body().Set(fix.NewStringField(tag.Symbol, "A"))
	builder.Body().Set(fix.NewStringField(tag.Side, "A"))
	builder.Body().Set(fix.NewStringField(tag.OrderQty, "A"))

	builder.Header().Set(fix.NewStringField(tag.MsgType, "D"))
	builder.Header().Set(fix.NewStringField(tag.BeginString, "FIX.4.0"))
	builder.Header().Set(fix.NewStringField(tag.BodyLength, "0"))
	builder.Header().Set(fix.NewStringField(tag.SenderCompID, "0"))
	builder.Header().Set(fix.NewStringField(tag.TargetCompID, "0"))
	builder.Header().Set(fix.NewStringField(tag.MsgSeqNum, "0"))
	//sending time is required
	//msg.Header.FieldMap.Set(fix.NewStringField(tag.SendingTime, "0"))

	msgBytes, _ = builder.Build()
	msg, _ = parseMessage(msgBytes)

	reject = validate(dict, *msg)
	c.Check(reject, NotNil)
	c.Check(reject.RejectReason(), Equals, rejectReasonRequiredTagMissing)
	c.Check(*reject.RefTagID(), Equals, tag.SendingTime)
}