frostfs-api-go/netmap/test/generate.go

package netmaptest

import (
	netmap "git.frostfs.info/TrueCloudLab/aarifullin/v2/netmap/grpc"
	refstest "git.frostfs.info/TrueCloudLab/aarifullin/v2/refs/test"
	sessiontest "git.frostfs.info/TrueCloudLab/aarifullin/v2/session/test"
)

func GenerateFilter(empty bool) *netmap.Filter {
	return generateFilter(empty, true)
}

func generateFilter(empty, withSub bool) *netmap.Filter {
	m := new(netmap.Filter)

	if !empty {
		m.SetKey("filter key")
		m.SetValue("filter value")
		m.SetName("filter name")
		m.SetOp(1)

		if withSub {
			m.SetFilters([]*netmap.Filter{
				generateFilter(empty, false),
				generateFilter(empty, false),
			})
		}
	}

	return m
}

func GenerateFilters(empty bool) []*netmap.Filter {
	var res []*netmap.Filter

	if !empty {
		res = append(res,
			GenerateFilter(false),
			GenerateFilter(false),
		)
	}

	return res
}

func GenerateSelector(empty bool) *netmap.Selector {
	m := new(netmap.Selector)

	if !empty {
		m.SetCount(66)
		m.SetAttribute("selector attribute")
		m.SetFilter("select filter")
		m.SetName("select name")
		m.SetClause(1)
	}

	return m
}

func GenerateSelectors(empty bool) []*netmap.Selector {
	var res []*netmap.Selector

	if !empty {
		res = append(res,
			GenerateSelector(false),
			GenerateSelector(false),
		)
	}

	return res
}

func GenerateReplica(empty bool) *netmap.Replica {
	m := new(netmap.Replica)

	if !empty {
		m.SetCount(42)
		m.SetSelector("replica selector")
	}

	return m
}

func GenerateReplicas(empty bool) []*netmap.Replica {
	var res []*netmap.Replica

	if !empty {
		res = append(res,
			GenerateReplica(false),
			GenerateReplica(false),
		)
	}

	return res
}

func GeneratePlacementPolicy(empty bool) *netmap.PlacementPolicy {
	m := new(netmap.PlacementPolicy)

	if !empty {
		m.SetContainerBackupFactor(322)
		m.SetFilters(GenerateFilters(false))
		m.SetSelectors(GenerateSelectors(false))
		m.SetReplicas(GenerateReplicas(false))
	}

	return m
}

func GenerateAttribute(empty bool) *netmap.NodeInfo_Attribute {
	m := new(netmap.NodeInfo_Attribute)

	if !empty {
		m.SetKey("attribute key")
		m.SetValue("attribute val")
	}

	return m
}

func GenerateAttributes(empty bool) []*netmap.NodeInfo_Attribute {
	var res []*netmap.NodeInfo_Attribute

	if !empty {
		res = append(res,
			GenerateAttribute(false),
			GenerateAttribute(false),
		)
	}

	return res
}

func GenerateNodeInfo(empty bool) *netmap.NodeInfo {
	m := new(netmap.NodeInfo)

	if !empty {
		m.SetAddresses([]string{"node address", "node address 2"})
		m.SetPublicKey([]byte{1, 2, 3})
		m.SetState(33)
		m.SetAttributes(GenerateAttributes(empty))
	}

	return m
}

func GenerateLocalNodeInfoRequestBody(_ bool) *netmap.LocalNodeInfoRequest_Body {
	m := new(netmap.LocalNodeInfoRequest_Body)

	return m
}

func GenerateLocalNodeInfoRequest(empty bool) *netmap.LocalNodeInfoRequest {
	m := new(netmap.LocalNodeInfoRequest)

	if !empty {
		m.SetBody(GenerateLocalNodeInfoRequestBody(false))
	}

	m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
	m.SetVerifyHeader(sessiontest.GenerateRequestVerificationHeader(empty))

	return m
}

func GenerateLocalNodeInfoResponseBody(empty bool) *netmap.LocalNodeInfoResponse_Body {
	m := new(netmap.LocalNodeInfoResponse_Body)

	if !empty {
		m.SetNodeInfo(GenerateNodeInfo(false))
	}

	m.SetVersion(refstest.GenerateVersion(empty))

	return m
}

func GenerateLocalNodeInfoResponse(empty bool) *netmap.LocalNodeInfoResponse {
	m := new(netmap.LocalNodeInfoResponse)

	if !empty {
		m.SetBody(GenerateLocalNodeInfoResponseBody(false))
	}

	m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
	m.SetVerifyHeader(sessiontest.GenerateResponseVerificationHeader(empty))

	return m
}

func GenerateNetworkParameter(empty bool) *netmap.NetworkConfig_Parameter {
	m := new(netmap.NetworkConfig_Parameter)

	if !empty {
		m.SetKey([]byte("key"))
		m.SetValue([]byte("value"))
	}

	return m
}

func GenerateNetworkConfig(empty bool) *netmap.NetworkConfig {
	m := new(netmap.NetworkConfig)

	if !empty {
		m.SetParameters([]*netmap.NetworkConfig_Parameter{
			GenerateNetworkParameter(empty),
			GenerateNetworkParameter(empty),
		})
	}

	return m
}

func GenerateNetworkInfo(empty bool) *netmap.NetworkInfo {
	m := new(netmap.NetworkInfo)

	if !empty {
		m.SetMagicNumber(228)
		m.SetCurrentEpoch(666)
		m.SetMsPerBlock(5678)
		m.SetNetworkConfig(GenerateNetworkConfig(empty))
	}

	return m
}

func GenerateNetworkInfoRequestBody(_ bool) *netmap.NetworkInfoRequest_Body {
	m := new(netmap.NetworkInfoRequest_Body)

	return m
}

func GenerateNetworkInfoRequest(empty bool) *netmap.NetworkInfoRequest {
	m := new(netmap.NetworkInfoRequest)

	if !empty {
		m.SetBody(GenerateNetworkInfoRequestBody(false))
	}

	m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
	m.SetVerifyHeader(sessiontest.GenerateRequestVerificationHeader(empty))

	return m
}

func GenerateNetworkInfoResponseBody(empty bool) *netmap.NetworkInfoResponse_Body {
	m := new(netmap.NetworkInfoResponse_Body)

	if !empty {
		m.SetNetworkInfo(GenerateNetworkInfo(false))
	}

	return m
}

func GenerateNetworkInfoResponse(empty bool) *netmap.NetworkInfoResponse {
	m := new(netmap.NetworkInfoResponse)

	if !empty {
		m.SetBody(GenerateNetworkInfoResponseBody(false))
	}

	m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
	m.SetVerifyHeader(sessiontest.GenerateResponseVerificationHeader(empty))

	return m
}

func GenerateNetMap(empty bool) *netmap.Netmap {
	m := new(netmap.Netmap)

	if !empty {
		m.SetEpoch(987)
		m.SetNodes([]*netmap.NodeInfo{
			GenerateNodeInfo(false),
			GenerateNodeInfo(false),
		})
	}

	return m
}

func GenerateSnapshotRequestBody(_ bool) *netmap.NetmapSnapshotRequest_Body {
	return new(netmap.NetmapSnapshotRequest_Body)
}

func GenerateSnapshotRequest(empty bool) *netmap.NetmapSnapshotRequest {
	m := new(netmap.NetmapSnapshotRequest)

	if !empty {
		m.SetBody(GenerateSnapshotRequestBody(false))
	}

	m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
	m.SetVerifyHeader(sessiontest.GenerateRequestVerificationHeader(empty))

	return m
}

func GenerateSnapshotResponseBody(empty bool) *netmap.NetmapSnapshotResponse_Body {
	m := new(netmap.NetmapSnapshotResponse_Body)

	if !empty {
		m.SetNetmap(GenerateNetMap(false))
	}

	return m
}

func GenerateSnapshotResponse(empty bool) *netmap.NetmapSnapshotResponse {
	m := new(netmap.NetmapSnapshotResponse)

	if !empty {
		m.SetBody(GenerateSnapshotResponseBody(false))
	}

	m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
	m.SetVerifyHeader(sessiontest.GenerateResponseVerificationHeader(empty))

	return m
}