private static void VerifyLinksPayload(Workspace w, CommonPayload payload, LinqQueryBuilder linqBuilder)
        {
            ArrayList expectedEntities = CommonPayload.CreateList(linqBuilder.QueryResult);

            if (payload == null)
            {
                AstoriaTestLog.AreEqual(expectedEntities.Count, 0, "Unexpected null $ref payload");
            }
            else
            {
                KeyExpressions expectedKeys = new KeyExpressions();
                foreach (object o in expectedEntities)
                {
                    KeyExpression keyExp = w.CreateKeyExpressionFromProviderObject(o);
                    expectedKeys.Add(keyExp);
                }

                List <string> linksFound = new List <string>();

                if (payload.Resources == null)
                {
                    linksFound.Add(payload.Value);
                }
                else
                {
                    foreach (PayloadObject o in (payload.Resources as List <PayloadObject>))
                    {
                        if (o.PayloadProperties.Any(p => p.Name == "uri"))
                        {
                            linksFound.Add((o["uri"] as PayloadSimpleProperty).Value);
                        }
                    }
                }

                AstoriaTestLog.AreEqual(expectedKeys.Count, linksFound.Count, "Number of expected entities does not match number of links found");

                foreach (string link in linksFound)
                {
                    KeyExpression match = null;
                    foreach (KeyExpression expectedKey in expectedKeys)
                    {
                        if (compareKeyURI(link, expectedKey))
                        {
                            match = expectedKey;
                            break;
                        }
                    }

                    if (match != null)
                    {
                        expectedKeys.Remove(match);
                    }
                    else
                    {
                        AstoriaTestLog.WriteLineIgnore("Unexpected URI: '" + link + "'");
                        AstoriaTestLog.FailAndThrow("Unexpected URI found in $ref payload");
                    }
                }
            }
        }
Beispiel #2
0
        //---------------------------------------------------------------------
        // Replaces existing method code with that from embedded resources.
        //---------------------------------------------------------------------
        protected string ReplaceCode(string existingCode, string methodRegex, string resourceName)
        {
            // Find embedded resource.
            foreach (string fullName in GetType().Assembly.GetManifestResourceNames())
            {
                if (fullName.Contains(resourceName))
                {
                    // Replace type resolver.
                    using (StreamReader reader = new StreamReader(GetType().Assembly.GetManifestResourceStream(fullName), true))
                    {
                        // Read new code from resources.
                        string newCode = reader.ReadToEnd();

                        // Find method signature in existing code and replace
                        Regex method = new Regex(methodRegex, RegexOptions.Singleline);
                        if (method.Match(existingCode).Success)
                        {
                            return(method.Replace(existingCode, newCode));
                        }

                        AstoriaTestLog.FailAndThrow("Test error: unable to match " + methodRegex + " in embedded code: " + existingCode);
                        return(null);
                    }
                }
            }
            AstoriaTestLog.FailAndThrow("Test error: unable to find embedded resource: " + existingCode);
            return(null);
        }
Beispiel #3
0
        public AstoriaServiceHost(Workspace workspace, string webDataServicePrefixName, string machineName, AstoriaDatabase database)
            : base(workspace, webDataServicePrefixName, machineName, database)
        {
            if (AstoriaTestProperties.Host == Host.IDSH || AstoriaTestProperties.Host == Host.IDSH2)
            {
                if (AstoriaTestProperties.HostAuthenicationMethod != "None")
                {
                    AstoriaTestLog.FailAndThrow("Test implementations of IDSH do not support authentication");
                }
            }

            waitHandleName      = waitHandlePrefix + identifier;
            serviceInstanceName = this.WebDataServicePrefixName + "_" + identifier;
            exeName             = serviceName + this.WebDataServicePrefixName;

            if (ProcessHelper.IsLocalMachine(this.MachineName))
            {
                DestinationFolder       = Path.Combine(serviceHostFolder, serviceInstanceName);
                DestinationFolder_Local = DestinationFolder;
                ExecutablePath          = Path.Combine(DestinationFolder, exeName + ".exe");
                localExecutablePath     = ExecutablePath;
            }
            else
            {
                string remoteMachineLocalPath = IISHelper.GetLocalMachineWWWRootSharePath(this.MachineName);
                DestinationFolder_Local = Path.Combine(IISHelper.GetLocalMachineWWWRootSharePath(this.MachineName), serviceInstanceName);
                DestinationFolder       = Path.Combine(IISHelper.GetWWWRootSharePath(this.MachineName), serviceInstanceName);
                ExecutablePath          = Path.Combine(DestinationFolder, exeName + ".exe");
                localExecutablePath     = Path.Combine(DestinationFolder_Local, exeName + ".exe");
            }

            rootUri = Uri.UriSchemeHttp + "://" + this.MachineName + ":7777";
        }
Beispiel #4
0
        public virtual void CompareSingleValue(object expected, bool stripQuotes, bool valueUri)
        {
            if (this.Resources == null && expected == null)
            {
                return;
            }

            PayloadSimpleProperty simpleProperty = this.Resources as PayloadSimpleProperty;

            if (simpleProperty == null)
            {
                AstoriaTestLog.FailAndThrow("Payload did not represent a single value");
            }

            if (expected == null)
            {
                if (!simpleProperty.IsNull)
                {
                    AstoriaTestLog.FailAndContinue(new TestFailedException("Compare failed - Expected: null, got: " + simpleProperty.Value));
                }
            }
            else
            {
                ComparePrimitiveValuesObjectAndString(expected, expected.GetType(), simpleProperty.Value, valueUri, this.Format, false);
            }
        }
 public static void VerifyConcurrency(AstoriaResponse response)
 {
     if (response.Request.ETagHeaderExpected)
     {
         if (!response.ETagHeaderFound && !RequestUtil.ExpectEmptyHeaders(response))
         {
             AstoriaTestLog.FailAndThrow("Missing ETag header in response");
         }
     }
     else if (response.ETagHeaderFound)
     {
         if (string.IsNullOrEmpty(response.ETagHeader))
         {
             if (Versioning.Server.BugFixed_NullETagWhenTypeHasNoConcurrency)
             {
                 AstoriaTestLog.FailAndThrow("Unexpected null ETag header in response");
             }
             else
             {
                 AstoriaTestLog.WriteLine("Ignoring unexpected null ETag header in response due to known bug");
             }
         }
         else
         {
             AstoriaTestLog.FailAndThrow("Unexpected ETag header in response: '" + response.ETagHeader + "'");
         }
     }
 }
Beispiel #6
0
 //---------------------------------------------------------------------
 // Adds code from embedded resources to data service source file.
 //---------------------------------------------------------------------
 protected void InjectCode(Workspace w, params string[] resourceNames)
 {
     foreach (string resourceName in resourceNames)
     {
         // Find embedded resource.
         bool found = false;
         foreach (string fullName in GetType().Assembly.GetManifestResourceNames())
         {
             if (fullName.Contains(resourceName))
             {
                 // Append contents to service code.
                 using (StreamReader reader = new StreamReader(GetType().Assembly.GetManifestResourceStream(fullName), true))
                 {
                     w.GlobalAdditionalCode += reader.ReadToEnd();
                     found = true;
                     break;
                 }
             }
         }
         if (!found)
         {
             AstoriaTestLog.FailAndThrow("Test error: embedded resource not found!");
         }
     }
 }
 /// <summary>
 /// Constructs a new CodeGeneratingDataInserter for the given workspace
 /// </summary>
 /// <param name="w">the worspace to add data to</param>
 public CodeGeneratingDataInserter(Workspace w)
 {
     if (w.DataLayerProviderKind != DataLayerProviderKind.InMemoryLinq && w.DataLayerProviderKind != DataLayerProviderKind.NonClr)
     {
         AstoriaTestLog.FailAndThrow("CodeGeneratingDataInserter only supported for InMemory and NonClr workspaces");
     }
     workspace = w;
 }
Beispiel #8
0
        //---------------------------------------------------------------------
        // Sends and verifies request for all possible access rights.
        //---------------------------------------------------------------------
        public void TestAccess(string container)
        {
            // Save current state.
            HttpStatusCode normalStatusCode = ExpectedStatusCode;

#if !ClientSKUFramework
            for (uint i = 0; i <= (uint)Microsoft.OData.Service.EntitySetRights.All; i++)
            {
                // Set entity set access right.
                Workspace.DataService.ConfigSettings.SetEntitySetAccessRule(container, (Microsoft.OData.Service.EntitySetRights)i);

                // Calculate minimum access needed for request to succeed.
                Microsoft.OData.Service.EntitySetRights minAccess = Microsoft.OData.Service.EntitySetRights.All;
                switch (Verb)
                {
                case RequestVerb.Post: minAccess = Microsoft.OData.Service.EntitySetRights.WriteAppend; break;

                case RequestVerb.Get: minAccess = Microsoft.OData.Service.EntitySetRights.ReadSingle; break;

                case RequestVerb.Put: minAccess = Microsoft.OData.Service.EntitySetRights.WriteReplace | Microsoft.OData.Service.EntitySetRights.ReadSingle; break;

                case RequestVerb.Patch: minAccess = Microsoft.OData.Service.EntitySetRights.WriteMerge | Microsoft.OData.Service.EntitySetRights.ReadSingle; break;

                case RequestVerb.Delete: minAccess = Microsoft.OData.Service.EntitySetRights.WriteDelete | Microsoft.OData.Service.EntitySetRights.ReadSingle; break;

                default:
                    AstoriaTestLog.FailAndThrow("Test issue - unknown request verb (2)");
                    break;
                }

                // Calculate expected status code.
                ExpectedStatusCode =
                    i == 0 ? HttpStatusCode.NotFound
                    : (i & (uint)minAccess) == (uint)minAccess ? normalStatusCode : HttpStatusCode.Forbidden;

                // Send and verify request.
                AstoriaResponse response = SendAndVerify(null);

                // Delete the entity if it was created to avoid "key already exists" collisions.
                if (response.Headers.ContainsKey("Location"))
                {
                    string newEntity = response.Headers["Location"];

                    Workspace.DataService.ConfigSettings.SetEntitySetAccessRule(container, Microsoft.OData.Service.EntitySetRights.WriteDelete | Microsoft.OData.Service.EntitySetRights.ReadSingle);


                    BlobsRequest.MLE(Workspace, Format, RequestVerb.Delete, null, HttpStatusCode.NoContent, newEntity).SendAndVerify(null);
                }
            }
#endif


            // Restore previous state.
            ExpectedStatusCode = normalStatusCode;
#if !ClientSKUFramework
            Workspace.DataService.ConfigSettings.SetEntitySetAccessRule(container, Microsoft.OData.Service.EntitySetRights.All);
#endif
        }
Beispiel #9
0
        public static T Execute <T>(Func <T> f, bool inWebRequest, out System.Net.WebException exc)
        {
            exc = null;
            for (int i = 0; i < SocketExceptionRetries; i++)
            {
                try
                {
                    exc = null;
                    return(TrustedMethods.ReturnFuncResult <T>(f));
                }
                catch (WebException ex)
                {
                    exc = ex;
                    if (ex.InnerException is SocketException)
                    {
                        HandleSocketException(inWebRequest, (SocketException)exc.InnerException);
                    }
                    else
                    {
                        if (inWebRequest)
                        {
                            return(default(T)); // it will handle this
                        }
                        if (ex.Status == WebExceptionStatus.Timeout && CatchTimeouts)
                        {
                            HandleWebRequestTimeout(inWebRequest, ex);
                        }
                        else
                        {
                            throw ex;
                        }
                    }
                }
                catch (Exception ex)
                {
                    if (ex.InnerException == null || !(ex.InnerException is System.Net.WebException))
                    {
                        throw ex;
                    }

                    exc = (WebException)ex.InnerException;
                    if (exc.InnerException != null && (exc.InnerException is SocketException))
                    {
                        HandleSocketException(inWebRequest, (SocketException)exc.InnerException);
                    }
                    else if (exc.Status == WebExceptionStatus.Timeout && CatchTimeouts)
                    {
                        HandleWebRequestTimeout(inWebRequest, exc);
                    }
                    else
                    {
                        throw ex;
                    }
                }
            }
            AstoriaTestLog.FailAndThrow("Repeated socket exceptions encountered, consequences unpredictable.");
            return(default(T));
        }
Beispiel #10
0
        public static void Verify(APICallLogBuilder callLogBuilder, AstoriaResponse response, params ComplexType[] types)
        {
            if (!response.Request.LogAPICalls)
            {
                AstoriaTestLog.FailAndThrow("Cannot verify call order when the request did not log the calls");
            }

            Verify(callLogBuilder, response, Equal, types);
        }
Beispiel #11
0
        public static BatchResponse ParseBatchResponse(BatchRequest batchRequest, StringReader reader, string boundary)
        {
            // even if content-id is specified, we may not get it back in error cases. This doesn't feel entirely correct, it seems like there should
            // always be a 1-1 mapping that explicitly honors content-id's

            // TODO: responses / requests without content IDs should be matched up in order within changeset only
            // changesets should have the right number of responses too

            BatchResponse           response           = null;// new BatchResponse(batchRequest);
            List <ResponseFragment> unmatchedFragments = new List <ResponseFragment>();
            List <AstoriaRequest>   unmatchedRequests  = batchRequest.Requests
                                                         .Union(batchRequest.Changesets.SelectMany(changeset => changeset.AsEnumerable()))
                                                         .ToList();

            foreach (ResponseFragment fragment in ParseBatchResponse(reader, boundary))
            {
                AstoriaRequest request = null;

                if (fragment.ContentID != null)
                {
                    request = unmatchedRequests
                              .FirstOrDefault(r => r.Headers.ContainsKey("Content-ID") &&
                                              r.Headers["Content-ID"].Equals(fragment.ContentID));
                }

                if (request == null)
                {
                    unmatchedFragments.Add(fragment);
                }
                else
                {
                    unmatchedRequests.Remove(request);

                    response.Responses.Add(FragmentToResponse(request, fragment));
                }
            }

            if (unmatchedFragments.Any())
            {
                if (unmatchedFragments.Count < unmatchedRequests.Count)
                {
                    AstoriaTestLog.WriteLine("Warning: recieved fewer batch response fragments than expected");
                }
                else if (unmatchedFragments.Count > unmatchedRequests.Count)
                {
                    AstoriaTestLog.FailAndThrow("Recieved more batch fragments than expected");
                }

                for (int i = 0; i < unmatchedFragments.Count; i++)
                {
                    response.Responses.Add(FragmentToResponse(unmatchedRequests[i], unmatchedFragments[i]));
                }
            }

            return(response);
        }
        public static void VerifySpecificResponseVersion(AstoriaResponse response, int major, int minor)
        {
            if (response.DataServiceVersion == null)
            {
                AstoriaTestLog.FailAndThrow("Data service version should always be specified in response");
            }

            AstoriaTestLog.IsTrue(response.DataServiceVersion.StartsWith(major + "." + minor),
                                  String.Format("Unexpected value in response's DataServiceVersion header: {0}, expected: {1}.{2}", response.DataServiceVersion, major, minor));
        }
Beispiel #13
0
        private static IEnumerable <ResponseFragment> ParseBatchResponse(StringReader reader, string boundary)
        {
            //--batchresponse_aa2a62c3-d5f4-447e-9302-d31f062b02f7
            //Content-Type: multipart/mixed; boundary=changesetresponse_1837899f-f0ce-447e-a980-d2596a561051

            string boundaryLine = reader.ReadLine();

            if (!boundaryLine.Contains(boundary))
            {
                AstoriaTestLog.FailAndThrow(String.Format("Unexpected line in batch response: '{0}', expected boundary '{1}'", boundaryLine, boundary));
            }

            string headerLine;

            while (null != (headerLine = reader.ReadLine()))
            {
                Match match = Regex.Match(headerLine, @"Content-Type: multipart/mixed; boundary=(\S+)");

                if (match.Success)
                {
                    // eat the extra newline
                    reader.ReadLine();

                    foreach (ResponseFragment fragment in ParseChangeSet(reader, match.Groups[1].Value, boundary))
                    {
                        yield return(fragment);
                    }
                }
                else
                {
                    // this might be a batch get instead

                    //--batch(36522ad7-fc75-4b56-8c71-56071383e77b)
                    //Content-Type: application/http
                    //Content-Transfer-Encoding:binary

                    if (!Regex.IsMatch(headerLine, @"Content-Type:\s+application/http"))
                    {
                        AstoriaTestLog.FailAndThrow(String.Format("Could not parse batch content type or boundary, line was '{0}'", headerLine));
                    }

                    headerLine = reader.ReadLine();
                    if (!Regex.IsMatch(headerLine, @"Content-Transfer-Encoding:\s+binary"))
                    {
                        AstoriaTestLog.FailAndThrow(String.Format("Missing content-transfer-encoding, line was '{0}'", headerLine));
                    }

                    // eat the extra newline
                    reader.ReadLine();

                    yield return(ParseBatchFragment(reader, boundary));
                }
            }
        }
Beispiel #14
0
        //---------------------------------------------------------------------
        public static BlobsPayload Parse(SerializationFormatKind format, AstoriaResponse response)
        {
            switch (format)
            {
            case SerializationFormatKind.Atom: return(new BlobsPayload.Atom(response.Payload));

            case SerializationFormatKind.JSON: return(new BlobsPayload.JSON(response.Payload));

            default:
                AstoriaTestLog.FailAndThrow("Unknown serialization format kind: " + format.ToString());
                return(null);
            }
        }
Beispiel #15
0
        public static KeyExpression ConstructKey(ResourceContainer container, PayloadObject entity)
        {
            Dictionary <string, object> properties = new Dictionary <string, object>();

            ResourceType type = container.BaseType;

            if (entity.Type != type.Namespace + "." + type.Name)
            {
                type = container.ResourceTypes.SingleOrDefault(rt => rt.Namespace + "." + rt.Name == entity.Type);
                if (type == null)
                {
                    AstoriaTestLog.FailAndThrow("Could not find resource type for payload type value: " + entity.Type);
                }
            }

            foreach (ResourceProperty property in type.Properties.OfType <ResourceProperty>())
            {
                if (property.IsNavigation || property.IsComplexType)
                {
                    continue;
                }

                string propertyName = property.Name;
                string valueString;
                if (entity.PayloadProperties.Any(p => p.Name == propertyName))
                {
                    PayloadSimpleProperty simpleProperty = entity[propertyName] as PayloadSimpleProperty;
                    if (simpleProperty == null)
                    {
                        continue;
                    }

                    valueString = simpleProperty.Value;
                }
                else
                {
                    continue;
                }

                object value = CommonPayload.DeserializeStringToObject(valueString, property.Type.ClrType, false, entity.Format);
                if (value is DateTime && entity.Format == SerializationFormatKind.JSON)
                {
                    // TODO: this is because the server will make any JSON datetime into UTC, and currently we always send 'unspecified' values
                    value = new DateTime(((DateTime)value).Ticks, DateTimeKind.Unspecified);
                }

                properties[propertyName] = value;
            }

            return(new KeyExpression(container, type, properties));
        }
Beispiel #16
0
        private static ResponseFragment ParseBatchFragment(StringReader reader, string boundary)
        {
            //HTTP/1.1 200 Ok
            //Content-Type: application/atom+xml;type=entry
            //Content-Length: ###

            string line  = reader.ReadLine();
            Match  match = Regex.Match(line, @"HTTP/1.1 ([0-9]{3}).*");

            if (!match.Success)
            {
                AstoriaTestLog.FailAndThrow(String.Format("Expected HTTP protocol and status code, got '{0}'", line));
            }

            HttpStatusCode statusCode = (HttpStatusCode)Enum.Parse(typeof(HttpStatusCode), match.Groups[1].Value);

            Dictionary <string, string> headers = new Dictionary <string, string>();

            while (null != (line = reader.ReadLine()) &&
                   !line.Contains(boundary) &&
                   (match = Regex.Match(line, @"([A-Za-z-]+):\s*(.+)")).Success)
            {
                string headerString = match.Groups[1].Value;//.Replace("-", String.Empty).ToLowerInvariant();
                string value        = match.Groups[2].Value;

                headers.Add(headerString, value);
            }

            // the rest is payload
            StringBuilder payload = new StringBuilder();

            while (null != (line = reader.ReadLine()) && !line.Contains(boundary))
            {
                payload.AppendLine(line);
            }

            ResponseFragment fragment = new ResponseFragment()
            {
                ContentID   = null,
                ContentType = "application/xml", // will be overwritten if present
                Payload     = payload.ToString().Trim(),
                StatusCode  = statusCode,
                Headers     = headers
            };

            headers.TryGetValue("Content-Type", out fragment.ContentType);
            headers.TryGetValue("Content-ID", out fragment.ContentID);

            return(fragment);
        }
Beispiel #17
0
        public static XmlNode FindFirstChild(string payload)
        {
            XmlDocument xmlDocument = new XmlDocument();

            try
            {
                xmlDocument.LoadXml(payload);
            }
            catch
            {
                AstoriaTestLog.FailAndThrow("payload was not valid xml.");
            }

            return(xmlDocument.FirstChild.NextSibling);
        }
Beispiel #18
0
        public static void RegisterTypesForUnDeclaredProperties(Workspace w)
        {
            if (w.DataService == null || w.DataService.ConfigSettings == null)
            {
                AstoriaTestLog.FailAndThrow("Cannot register complex types as service is not set up yet");
            }

            IEnumerable <Type> toAdd = w.ServiceContainer.ResourceTypes
                                       .SelectMany(rt => rt.Properties.OfType <ResourceProperty>())
                                       .Where(rp => !rp.Facets.IsDeclaredProperty)
                                       .Select(rp => rp.Type.ClrType)
                                       .Distinct();
            //foreach (Type type in toAdd)
            //    w.DataService.ConfigSettings.AddRegisterKnownType(type.FullName);
        }
Beispiel #19
0
        private static bool MethodAllowed(ContainmentQuery query, ContainmentQuerySuffix suffix, RequestVerb verb)
        {
            if (query.SetExpected)
            {
                if (suffix != ContainmentQuerySuffix.None)
                {
                    AstoriaTestLog.FailAndThrow("Only the NONE suffix can be used when a set is expected");
                }

                return(verb == RequestVerb.Get || verb == RequestVerb.Post);
            }
            else
            {
                return(VerbMap.Valid(suffix, verb));
            }
        }
        private static T ConvertToEnum <T>(string value, T defaultValue)
        {
            if (string.IsNullOrEmpty(value))
            {
                return(defaultValue);
            }

            T converted = Enum.GetValues(typeof(T)).Cast <T>().SingleOrDefault(e => e.ToString().Equals(value, StringComparison.InvariantCultureIgnoreCase));

            if (converted == null)
            {
                AstoriaTestLog.FailAndThrow(String.Format("Could not convert value '{0}' into enum type '{1}'", value, typeof(T)));
            }

            return(converted);
        }
Beispiel #21
0
        public ResourceInstanceProperty this[string name]
        {
            get
            {
                return(this.FirstOrDefault(p => p.Name == name));
            }
            set
            {
                if (value.Name != name)
                {
                    AstoriaTestLog.FailAndThrow("Cannot add property with wrong name");
                }

                this.Add(value);
            }
        }
Beispiel #22
0
        public static void Verify(List <APICallLogEntry> expectedCalls, List <APICallLogEntry> observedCalls, Func <APICallLogEntry, APICallLogEntry, bool> compare)
        {
            observedCalls = observedCalls.Where(e => !ClassesToIgnore.Any(c => e.MethodName.StartsWith(c + "."))).ToList();

            List <int> mismatchedLines = new List <int>();

            AstoriaTestLog.WriteLineIgnore("Observed call order: ");
            for (int i = 0; i < observedCalls.Count; i++)
            {
                if (i >= expectedCalls.Count || !compare(expectedCalls[i], observedCalls[i]))
                {
                    AstoriaTestLog.WriteLine("(Observed) " + i + " - " + observedCalls[i].ToString());
                    mismatchedLines.Add(i);
                }
                else if (!AstoriaTestProperties.IsLabRun)
                {
                    AstoriaTestLog.WriteLineIgnore("(Observed) " + i + " - " + observedCalls[i].ToString());
                }
            }

            if (observedCalls.Count < expectedCalls.Count)
            {
                for (int i = observedCalls.Count; i < expectedCalls.Count; i++)
                {
                    mismatchedLines.Add(i);
                }
            }

            if (mismatchedLines.Any())
            {
                AstoriaTestLog.WriteLineIgnore("Expected call order: ");
                for (int i = 0; i < expectedCalls.Count; i++)
                {
                    if (mismatchedLines.Contains(i))
                    {
                        AstoriaTestLog.WriteLine("(Expected) " + i + " - " + expectedCalls[i].ToString());
                    }
                    else
                    {
                        AstoriaTestLog.WriteLineIgnore("(Expected) " + i + " - " + expectedCalls[i].ToString());
                    }
                }

                AstoriaTestLog.FailAndThrow("Observed call log did not match baseline");
            }
        }
Beispiel #23
0
        private T LoadProperty <T>(object entity, string propertyName)
        {
            if (entity == null)
            {
                throw new ArgumentNullException("entity");
            }

            if (propertyName == null)
            {
                throw new ArgumentNullException("propertyName");
            }

            object value;

            if (TryLoadProperty_EF(entity, propertyName, out value))
            {
                return((T)value);
            }

            // L2S types have the DataServiceKey attribute, need to try them first
            if (TryLoadProperty_L2S(entity, propertyName, out value))
            {
                return((T)value);
            }

            if (TryLoadProperty_Client(entity, propertyName, out value))
            {
                return((T)value);
            }
#if !ClientSKUFramework
            if (TryLoadProperty_RowEntityType(entity, propertyName, out value))
            {
                return((T)value);
            }
#endif

            if (TryLoadProperty_Reflection(entity, propertyName, out value))
            {
                return((T)value);
            }

            AstoriaTestLog.FailAndThrow("Could not load property '" + propertyName + "' on entity of type '" + entity.GetType() + "'");
            return(default(T));
        }
        private static string ParseResponseErrorJSON(AstoriaResponse response, bool inStream)
        {
            // error should be something like
            //{
            //  "error": {
            //    "code": "", "message":  "Error message"
            //  }
            //}
            ServiceError serviceError  = new ServiceError();
            string       payloadString = response.Payload;

            CommonPayload payload;

            if (inStream)
            {
                Match match = JsonInStreamErrorRegex.Match(payloadString);
                if (!match.Success)
                {
                    AstoriaTestLog.TraceLine(payloadString);
                    AstoriaTestLog.FailAndThrow("Payload did not contain expected in-stream error");
                }
                response.Payload = match.Groups[1].Value;
            }
            payload = response.CommonPayload;

            PayloadProperty        prop;
            PayloadComplexProperty complex = payload.Resources as PayloadComplexProperty;

            if (complex != null)
            {
                if (complex.PayloadProperties.TryGetValue("message", out prop))
                {
                    if (prop is PayloadComplexProperty)
                    {
                        if ((prop as PayloadComplexProperty).PayloadProperties.TryGetValue("value", out prop))
                        {
                            serviceError.message = (prop as PayloadSimpleProperty).Value;
                        }
                    }
                }
            }

            return(serviceError.message);
        }
Beispiel #25
0
        protected void CompareDynamicPropertyValues(PayloadProperty inserted, PayloadProperty returned)
        {
            if (inserted.IsNull || returned.IsNull)
            {
                if (!inserted.IsNull)
                {
                    AstoriaTestLog.FailAndThrow("Null inserted value was non-null in return payload");
                }
                if (!returned.IsNull)
                {
                    AstoriaTestLog.FailAndThrow("Non-null inserted value was null in return payload");
                }
            }
            else
            {
                NodeType insertType = GetDynamicPropertyType(inserted);
                NodeType returnType = GetDynamicPropertyType(returned);

                if (inserted.MappedOutOfContent == returned.MappedOutOfContent)
                {
                    bool equivalentTypes = false;
                    if (EquivalentValues(insertType, inserted, returnType, returned))
                    {
                        equivalentTypes = true;
                    }
                    if (EquivalentValues(returnType, returned, insertType, inserted))
                    {
                        equivalentTypes = true;
                    }

                    if (!equivalentTypes)
                    {
                        AstoriaTestLog.AreEqual(insertType, returnType, "Type of inserted/updated dynamic property value does not match returned type for property", false);
                    }
                }
                else if (inserted.MappedOutOfContent)
                {
                    insertType = returnType;
                }

                ComparePropertyValues(insertType, inserted, returned, true);
            }
        }
Beispiel #26
0
        public static KeyExpression GetContainingKey(this ContainmentAttribute att, KeyExpression childKey, ResourceType parentType, bool abbreviate)
        {
            AstoriaTestLog.Compare(childKey.ResourceContainer == att.ChildContainer,
                                   String.Format("ChildKey does not belong to expected set (Expected '{0}', got '{1}'", att.ChildContainer.Name, childKey.ResourceContainer.Name));

            List <PropertyExpression> parentProperties = new List <PropertyExpression>();
            List <ConstantExpression> parentValues     = new List <ConstantExpression>();

            foreach (NodeProperty p_prop in att.ParentContainer.BaseType.Key.Properties)
            {
                string c_name;
                if (!att.KeyMapping.TryGetValue(p_prop.Name, out c_name))
                {
                    AstoriaTestLog.FailAndThrow(String.Format("Parent key property {0} does not appear in derived key mapping", p_prop.Name));
                }

                // need to get the offset now
                int c_offset = 0;
                for (; c_offset < childKey.Properties.Length; c_offset++)
                {
                    if (childKey.Properties[c_offset].Name == c_name)
                    {
                        break;
                    }
                }
                if (c_offset >= childKey.Properties.Length)
                {
                    AstoriaTestLog.FailAndThrow(String.Format("Could not find property '{0}' in child key", c_name));
                }

                NodeProperty c_prop = childKey.Properties[c_offset];

                parentProperties.Add(p_prop.Property());
                parentValues.Add(new ConstantExpression(childKey.Values[c_offset]));

                if (abbreviate)
                {
                    childKey.IncludeInUri[c_offset] = false;
                }
            }

            return(new KeyExpression(att.ParentContainer, parentType, parentProperties.ToArray(), parentValues.ToArray()));
        }
Beispiel #27
0
        public static Dictionary <string, string> ParseETag(ResourceType type, string ETag)
        {
            string[]      values         = SplitETag(ETag);
            List <string> etagProperties = type.Properties.Where(p => p.Facets.ConcurrencyModeFixed).Select(p => p.Name).ToList();

            if (values.Length != etagProperties.Count)
            {
                AstoriaTestLog.FailAndThrow("Could not parse etag");
                return(null);
            }
            else
            {
                Dictionary <string, string> etagMap = new Dictionary <string, string>();
                for (int i = 0; i < values.Length; i++)
                {
                    etagMap[etagProperties[i]] = values[i];
                }
                return(etagMap);
            }
        }
Beispiel #28
0
        private static IEnumerable <ResponseFragment> ParseChangeSet(StringReader reader, string changeSetBoundary, string batchBoundary)
        {
            // first line should be the boundary
            // second line should be content type
            // third line should be content-transfer-encoding

            //--changesetresponse_1837899f-f0ce-447e-a980-d2596a561051
            //Content-Type: application/http
            //Content-Transfer-Encoding: binary

            string boundaryLine = reader.ReadLine();

            if (!boundaryLine.Contains(changeSetBoundary))
            {
                AstoriaTestLog.FailAndThrow(String.Format("Unexpected line in batch response: '{0}', expected boundary '{1}'", boundaryLine, changeSetBoundary));
            }

            string line;

            while (null != (line = reader.ReadLine()) && !line.Contains(batchBoundary))
            {
                if (!Regex.IsMatch(line, @"Content-Type:\s*application/http"))
                {
                    AstoriaTestLog.FailAndThrow(String.Format("Could not parse change set content type, line was '{0}'", line));
                }

                line = reader.ReadLine();
                if (!Regex.IsMatch(line, @"Content-Transfer-Encoding:\s*binary"))
                {
                    AstoriaTestLog.FailAndThrow(String.Format("Missing change set content-transfer-encoding, line was '{0}'", line));
                }

                // eat the newline
                reader.ReadLine();

                yield return(ParseBatchFragment(reader, changeSetBoundary));
            }
        }
 public static string GetLocalizedResourceString(Workspace w, ResourceIdentifier identifier, bool isLocal, object[] args)
 {
     try
     {
         if (isLocal)
         {
             return(ResourceUtil.GetLocalizedResourceString(identifier, args));
         }
         else
         {
             return(w.GetLocalizedResourceString(identifier.Id, args));
         }
     }
     catch (ArgumentException e)
     {
         if (e.Message == ResourceUtil.MissingLocalizeResourceString)
         {
             AstoriaTestLog.FailAndThrow(String.Format("Resource identifier '{0}' could not be found {1}",
                                                       identifier.Id, (isLocal ? "locally" : "remotely")));
         }
         throw;
     }
 }
Beispiel #30
0
        public static void SetupDefaultOpenTypeAttributes(Workspace w)
        {
            if (w.DataLayerProviderKind != DataLayerProviderKind.NonClr)
            {
                AstoriaTestLog.FailAndThrow("Open types not supported for data-layers other than NonCLR");
            }

#if !ClientSKUFramework
            // let the open types tests do their own thing
            if (w is OpenTypesWorkspace)
            {
                return;
            }
#endif

            if (w.Name.Equals("Northwind", StringComparison.InvariantCultureIgnoreCase))
            {
                foreach (ResourceType type in w.ServiceContainer.ResourceTypes.Distinct().Where(t => !t.Facets.IsOpenType))
                {
                    type.Facets.Add(NodeFacet.Attribute(new OpenTypeResourceAttribute(type, (rp => rp.IsNavigation || rp.PrimaryKey != null || rp.Facets.ConcurrencyModeFixed))));
                }
            }
            else if (w.Name.Equals("Aruba", StringComparison.InvariantCultureIgnoreCase))
            {
                foreach (ResourceType type in w.ServiceContainer.ResourceTypes.Distinct().Where(t => !t.Facets.IsOpenType))
                {
                    type.Facets.Add(NodeFacet.Attribute(new OpenTypeResourceAttribute(type, (rp => rp.IsNavigation || rp.PrimaryKey != null || rp.Facets.ConcurrencyModeFixed))));
                }
            }

#if !ClientSKUFramework
            w.AfterServiceCreation.Add(() => (w as NonClrWorkspace).OpenTypeMethodsImplementation = System.Data.Test.Astoria.LateBound.OpenTypeMethodsImplementations.Realistic);
#endif
            // immediately after creating the service, register the undeclared properties' types
            w.AfterServiceCreation.Insert(0, () => RegisterTypesForUnDeclaredProperties(w));
        }